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     boolean hasType();
  16     com.openxc.BinaryMessages.VehicleMessage.Type getType();
  17
  18     // optional .openxc.CanMessage can_message = 2;
  19     boolean hasCanMessage();
  20     com.openxc.BinaryMessages.CanMessage getCanMessage();
  21     com.openxc.BinaryMessages.CanMessageOrBuilder getCanMessageOrBuilder();
  22
  23     // optional .openxc.SimpleMessage simple_message = 3;
  24     boolean hasSimpleMessage();
  25     com.openxc.BinaryMessages.SimpleMessage getSimpleMessage();
  26     com.openxc.BinaryMessages.SimpleMessageOrBuilder getSimpleMessageOrBuilder();
  27
  28     // optional .openxc.DiagnosticResponse diagnostic_response = 4;
  29     boolean hasDiagnosticResponse();
  30     com.openxc.BinaryMessages.DiagnosticResponse getDiagnosticResponse();
  31     com.openxc.BinaryMessages.DiagnosticResponseOrBuilder getDiagnosticResponseOrBuilder();
  32
  33     // optional .openxc.ControlCommand control_command = 5;
  34     boolean hasControlCommand();
  35     com.openxc.BinaryMessages.ControlCommand getControlCommand();
  36     com.openxc.BinaryMessages.ControlCommandOrBuilder getControlCommandOrBuilder();
  37
  38     // optional .openxc.CommandResponse command_response = 6;
  39     boolean hasCommandResponse();
  40     com.openxc.BinaryMessages.CommandResponse getCommandResponse();
  41     com.openxc.BinaryMessages.CommandResponseOrBuilder getCommandResponseOrBuilder();
  42
  43     // optional uint32 uptime = 7;
  44     boolean hasUptime();
  45     int getUptime();
  46   }
  47   public static final class VehicleMessage extends
  48       com.google.protobuf.GeneratedMessage
  49       implements VehicleMessageOrBuilder {
  50     // Use VehicleMessage.newBuilder() to construct.
  51     private VehicleMessage(Builder builder) {
  52       super(builder);
  53     }
  54     private VehicleMessage(boolean noInit) {}
  55
  56     private static final VehicleMessage defaultInstance;
  57     public static VehicleMessage getDefaultInstance() {
  58       return defaultInstance;
  59     }
  60
  61     public VehicleMessage getDefaultInstanceForType() {
  62       return defaultInstance;
  63     }
  64
  65     public static final com.google.protobuf.Descriptors.Descriptor
  66         getDescriptor() {
  67       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
  68     }
  69
  70     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
  71         internalGetFieldAccessorTable() {
  72       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable;
  73     }
  74
  75     public enum Type
  76         implements com.google.protobuf.ProtocolMessageEnum {
  77       CAN(0, 1),
  78       SIMPLE(1, 2),
  79       DIAGNOSTIC(2, 3),
  80       CONTROL_COMMAND(3, 4),
  81       COMMAND_RESPONSE(4, 5),
  82       ;
  83
  84       public static final int CAN_VALUE = 1;
  85       public static final int SIMPLE_VALUE = 2;
  86       public static final int DIAGNOSTIC_VALUE = 3;
  87       public static final int CONTROL_COMMAND_VALUE = 4;
  88       public static final int COMMAND_RESPONSE_VALUE = 5;
  89
  90
  91       public final int getNumber() { return value; }
  92
  93       public static Type valueOf(int value) {
  94         switch (value) {
  95           case 1: return CAN;
  96           case 2: return SIMPLE;
  97           case 3: return DIAGNOSTIC;
  98           case 4: return CONTROL_COMMAND;
  99           case 5: return COMMAND_RESPONSE;
 100           default: return null;
 101         }
 102       }
 103
 104       public static com.google.protobuf.Internal.EnumLiteMap<Type>
 105           internalGetValueMap() {
 106         return internalValueMap;
 107       }
 108       private static com.google.protobuf.Internal.EnumLiteMap<Type>
 109           internalValueMap =
 110             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
 111               public Type findValueByNumber(int number) {
 112                 return Type.valueOf(number);
 113               }
 114             };
 115
 116       public final com.google.protobuf.Descriptors.EnumValueDescriptor
 117           getValueDescriptor() {
 118         return getDescriptor().getValues().get(index);
 119       }
 120       public final com.google.protobuf.Descriptors.EnumDescriptor
 121           getDescriptorForType() {
 122         return getDescriptor();
 123       }
 124       public static final com.google.protobuf.Descriptors.EnumDescriptor
 125           getDescriptor() {
 126         return com.openxc.BinaryMessages.VehicleMessage.getDescriptor().getEnumTypes().get(0);
 127       }
 128
 129       private static final Type[] VALUES = {
 130         CAN, SIMPLE, DIAGNOSTIC, CONTROL_COMMAND, COMMAND_RESPONSE,
 131       };
 132
 133       public static Type valueOf(
 134           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
 135         if (desc.getType() != getDescriptor()) {
 136           throw new java.lang.IllegalArgumentException(
 137             "EnumValueDescriptor is not for this type.");
 138         }
 139         return VALUES[desc.getIndex()];
 140       }
 141
 142       private final int index;
 143       private final int value;
 144
 145       private Type(int index, int value) {
 146         this.index = index;
 147         this.value = value;
 148       }
 149
 150       // @@protoc_insertion_point(enum_scope:openxc.VehicleMessage.Type)
 151     }
 152
 153     private int bitField0_;
 154     // optional .openxc.VehicleMessage.Type type = 1;
 155     public static final int TYPE_FIELD_NUMBER = 1;
 156     private com.openxc.BinaryMessages.VehicleMessage.Type type_;
 157     public boolean hasType() {
 158       return ((bitField0_ & 0x00000001) == 0x00000001);
 159     }
 160     public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
 161       return type_;
 162     }
 163
 164     // optional .openxc.CanMessage can_message = 2;
 165     public static final int CAN_MESSAGE_FIELD_NUMBER = 2;
 166     private com.openxc.BinaryMessages.CanMessage canMessage_;
 167     public boolean hasCanMessage() {
 168       return ((bitField0_ & 0x00000002) == 0x00000002);
 169     }
 170     public com.openxc.BinaryMessages.CanMessage getCanMessage() {
 171       return canMessage_;
 172     }
 173     public com.openxc.BinaryMessages.CanMessageOrBuilder getCanMessageOrBuilder() {
 174       return canMessage_;
 175     }
 176
 177     // optional .openxc.SimpleMessage simple_message = 3;
 178     public static final int SIMPLE_MESSAGE_FIELD_NUMBER = 3;
 179     private com.openxc.BinaryMessages.SimpleMessage simpleMessage_;
 180     public boolean hasSimpleMessage() {
 181       return ((bitField0_ & 0x00000004) == 0x00000004);
 182     }
 183     public com.openxc.BinaryMessages.SimpleMessage getSimpleMessage() {
 184       return simpleMessage_;
 185     }
 186     public com.openxc.BinaryMessages.SimpleMessageOrBuilder getSimpleMessageOrBuilder() {
 187       return simpleMessage_;
 188     }
 189
 190     // optional .openxc.DiagnosticResponse diagnostic_response = 4;
 191     public static final int DIAGNOSTIC_RESPONSE_FIELD_NUMBER = 4;
 192     private com.openxc.BinaryMessages.DiagnosticResponse diagnosticResponse_;
 193     public boolean hasDiagnosticResponse() {
 194       return ((bitField0_ & 0x00000008) == 0x00000008);
 195     }
 196     public com.openxc.BinaryMessages.DiagnosticResponse getDiagnosticResponse() {
 197       return diagnosticResponse_;
 198     }
 199     public com.openxc.BinaryMessages.DiagnosticResponseOrBuilder getDiagnosticResponseOrBuilder() {
 200       return diagnosticResponse_;
 201     }
 202
 203     // optional .openxc.ControlCommand control_command = 5;
 204     public static final int CONTROL_COMMAND_FIELD_NUMBER = 5;
 205     private com.openxc.BinaryMessages.ControlCommand controlCommand_;
 206     public boolean hasControlCommand() {
 207       return ((bitField0_ & 0x00000010) == 0x00000010);
 208     }
 209     public com.openxc.BinaryMessages.ControlCommand getControlCommand() {
 210       return controlCommand_;
 211     }
 212     public com.openxc.BinaryMessages.ControlCommandOrBuilder getControlCommandOrBuilder() {
 213       return controlCommand_;
 214     }
 215
 216     // optional .openxc.CommandResponse command_response = 6;
 217     public static final int COMMAND_RESPONSE_FIELD_NUMBER = 6;
 218     private com.openxc.BinaryMessages.CommandResponse commandResponse_;
 219     public boolean hasCommandResponse() {
 220       return ((bitField0_ & 0x00000020) == 0x00000020);
 221     }
 222     public com.openxc.BinaryMessages.CommandResponse getCommandResponse() {
 223       return commandResponse_;
 224     }
 225     public com.openxc.BinaryMessages.CommandResponseOrBuilder getCommandResponseOrBuilder() {
 226       return commandResponse_;
 227     }
 228
 229     // optional uint32 uptime = 7;
 230     public static final int UPTIME_FIELD_NUMBER = 7;
 231     private int uptime_;
 232     public boolean hasUptime() {
 233       return ((bitField0_ & 0x00000040) == 0x00000040);
 234     }
 235     public int getUptime() {
 236       return uptime_;
 237     }
 238
 239     private void initFields() {
 240       type_ = com.openxc.BinaryMessages.VehicleMessage.Type.CAN;
 241       canMessage_ = com.openxc.BinaryMessages.CanMessage.getDefaultInstance();
 242       simpleMessage_ = com.openxc.BinaryMessages.SimpleMessage.getDefaultInstance();
 243       diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
 244       controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
 245       commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
 246       uptime_ = 0;
 247     }
 248     private byte memoizedIsInitialized = -1;
 249     public final boolean isInitialized() {
 250       byte isInitialized = memoizedIsInitialized;
 251       if (isInitialized != -1) return isInitialized == 1;
 252
 253       memoizedIsInitialized = 1;
 254       return true;
 255     }
 256
 257     public void writeTo(com.google.protobuf.CodedOutputStream output)
 258                         throws java.io.IOException {
 259       getSerializedSize();
 260       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 261         output.writeEnum(1, type_.getNumber());
 262       }
 263       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 264         output.writeMessage(2, canMessage_);
 265       }
 266       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 267         output.writeMessage(3, simpleMessage_);
 268       }
 269       if (((bitField0_ & 0x00000008) == 0x00000008)) {
 270         output.writeMessage(4, diagnosticResponse_);
 271       }
 272       if (((bitField0_ & 0x00000010) == 0x00000010)) {
 273         output.writeMessage(5, controlCommand_);
 274       }
 275       if (((bitField0_ & 0x00000020) == 0x00000020)) {
 276         output.writeMessage(6, commandResponse_);
 277       }
 278       if (((bitField0_ & 0x00000040) == 0x00000040)) {
 279         output.writeUInt32(7, uptime_);
 280       }
 281       getUnknownFields().writeTo(output);
 282     }
 283
 284     private int memoizedSerializedSize = -1;
 285     public int getSerializedSize() {
 286       int size = memoizedSerializedSize;
 287       if (size != -1) return size;
 288
 289       size = 0;
 290       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 291         size += com.google.protobuf.CodedOutputStream
 292           .computeEnumSize(1, type_.getNumber());
 293       }
 294       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 295         size += com.google.protobuf.CodedOutputStream
 296           .computeMessageSize(2, canMessage_);
 297       }
 298       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 299         size += com.google.protobuf.CodedOutputStream
 300           .computeMessageSize(3, simpleMessage_);
 301       }
 302       if (((bitField0_ & 0x00000008) == 0x00000008)) {
 303         size += com.google.protobuf.CodedOutputStream
 304           .computeMessageSize(4, diagnosticResponse_);
 305       }
 306       if (((bitField0_ & 0x00000010) == 0x00000010)) {
 307         size += com.google.protobuf.CodedOutputStream
 308           .computeMessageSize(5, controlCommand_);
 309       }
 310       if (((bitField0_ & 0x00000020) == 0x00000020)) {
 311         size += com.google.protobuf.CodedOutputStream
 312           .computeMessageSize(6, commandResponse_);
 313       }
 314       if (((bitField0_ & 0x00000040) == 0x00000040)) {
 315         size += com.google.protobuf.CodedOutputStream
 316           .computeUInt32Size(7, uptime_);
 317       }
 318       size += getUnknownFields().getSerializedSize();
 319       memoizedSerializedSize = size;
 320       return size;
 321     }
 322
 323     private static final long serialVersionUID = 0L;
 324     @java.lang.Override
 325     protected java.lang.Object writeReplace()
 326         throws java.io.ObjectStreamException {
 327       return super.writeReplace();
 328     }
 329
 330     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 331         com.google.protobuf.ByteString data)
 332         throws com.google.protobuf.InvalidProtocolBufferException {
 333       return newBuilder().mergeFrom(data).buildParsed();
 334     }
 335     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 336         com.google.protobuf.ByteString data,
 337         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 338         throws com.google.protobuf.InvalidProtocolBufferException {
 339       return newBuilder().mergeFrom(data, extensionRegistry)
 340                .buildParsed();
 341     }
 342     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(byte[] data)
 343         throws com.google.protobuf.InvalidProtocolBufferException {
 344       return newBuilder().mergeFrom(data).buildParsed();
 345     }
 346     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 347         byte[] data,
 348         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 349         throws com.google.protobuf.InvalidProtocolBufferException {
 350       return newBuilder().mergeFrom(data, extensionRegistry)
 351                .buildParsed();
 352     }
 353     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(java.io.InputStream input)
 354         throws java.io.IOException {
 355       return newBuilder().mergeFrom(input).buildParsed();
 356     }
 357     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 358         java.io.InputStream input,
 359         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 360         throws java.io.IOException {
 361       return newBuilder().mergeFrom(input, extensionRegistry)
 362                .buildParsed();
 363     }
 364     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(java.io.InputStream input)
 365         throws java.io.IOException {
 366       Builder builder = newBuilder();
 367       if (builder.mergeDelimitedFrom(input)) {
 368         return builder.buildParsed();
 369       } else {
 370         return null;
 371       }
 372     }
 373     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(
 374         java.io.InputStream input,
 375         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 376         throws java.io.IOException {
 377       Builder builder = newBuilder();
 378       if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
 379         return builder.buildParsed();
 380       } else {
 381         return null;
 382       }
 383     }
 384     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 385         com.google.protobuf.CodedInputStream input)
 386         throws java.io.IOException {
 387       return newBuilder().mergeFrom(input).buildParsed();
 388     }
 389     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 390         com.google.protobuf.CodedInputStream input,
 391         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 392         throws java.io.IOException {
 393       return newBuilder().mergeFrom(input, extensionRegistry)
 394                .buildParsed();
 395     }
 396
 397     public static Builder newBuilder() { return Builder.create(); }
 398     public Builder newBuilderForType() { return newBuilder(); }
 399     public static Builder newBuilder(com.openxc.BinaryMessages.VehicleMessage prototype) {
 400       return newBuilder().mergeFrom(prototype);
 401     }
 402     public Builder toBuilder() { return newBuilder(this); }
 403
 404     @java.lang.Override
 405     protected Builder newBuilderForType(
 406         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 407       Builder builder = new Builder(parent);
 408       return builder;
 409     }
 410     public static final class Builder extends
 411         com.google.protobuf.GeneratedMessage.Builder<Builder>
 412        implements com.openxc.BinaryMessages.VehicleMessageOrBuilder {
 413       public static final com.google.protobuf.Descriptors.Descriptor
 414           getDescriptor() {
 415         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 416       }
 417
 418       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 419           internalGetFieldAccessorTable() {
 420         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable;
 421       }
 422
 423       // Construct using com.openxc.BinaryMessages.VehicleMessage.newBuilder()
 424       private Builder() {
 425         maybeForceBuilderInitialization();
 426       }
 427
 428       private Builder(BuilderParent parent) {
 429         super(parent);
 430         maybeForceBuilderInitialization();
 431       }
 432       private void maybeForceBuilderInitialization() {
 433         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
 434           getCanMessageFieldBuilder();
 435           getSimpleMessageFieldBuilder();
 436           getDiagnosticResponseFieldBuilder();
 437           getControlCommandFieldBuilder();
 438           getCommandResponseFieldBuilder();
 439         }
 440       }
 441       private static Builder create() {
 442         return new Builder();
 443       }
 444
 445       public Builder clear() {
 446         super.clear();
 447         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.CAN;
 448         bitField0_ = (bitField0_ & ~0x00000001);
 449         if (canMessageBuilder_ == null) {
 450           canMessage_ = com.openxc.BinaryMessages.CanMessage.getDefaultInstance();
 451         } else {
 452           canMessageBuilder_.clear();
 453         }
 454         bitField0_ = (bitField0_ & ~0x00000002);
 455         if (simpleMessageBuilder_ == null) {
 456           simpleMessage_ = com.openxc.BinaryMessages.SimpleMessage.getDefaultInstance();
 457         } else {
 458           simpleMessageBuilder_.clear();
 459         }
 460         bitField0_ = (bitField0_ & ~0x00000004);
 461         if (diagnosticResponseBuilder_ == null) {
 462           diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
 463         } else {
 464           diagnosticResponseBuilder_.clear();
 465         }
 466         bitField0_ = (bitField0_ & ~0x00000008);
 467         if (controlCommandBuilder_ == null) {
 468           controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
 469         } else {
 470           controlCommandBuilder_.clear();
 471         }
 472         bitField0_ = (bitField0_ & ~0x00000010);
 473         if (commandResponseBuilder_ == null) {
 474           commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
 475         } else {
 476           commandResponseBuilder_.clear();
 477         }
 478         bitField0_ = (bitField0_ & ~0x00000020);
 479         uptime_ = 0;
 480         bitField0_ = (bitField0_ & ~0x00000040);
 481         return this;
 482       }
 483
 484       public Builder clone() {
 485         return create().mergeFrom(buildPartial());
 486       }
 487
 488       public com.google.protobuf.Descriptors.Descriptor
 489           getDescriptorForType() {
 490         return com.openxc.BinaryMessages.VehicleMessage.getDescriptor();
 491       }
 492
 493       public com.openxc.BinaryMessages.VehicleMessage getDefaultInstanceForType() {
 494         return com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance();
 495       }
 496
 497       public com.openxc.BinaryMessages.VehicleMessage build() {
 498         com.openxc.BinaryMessages.VehicleMessage result = buildPartial();
 499         if (!result.isInitialized()) {
 500           throw newUninitializedMessageException(result);
 501         }
 502         return result;
 503       }
 504
 505       private com.openxc.BinaryMessages.VehicleMessage buildParsed()
 506           throws com.google.protobuf.InvalidProtocolBufferException {
 507         com.openxc.BinaryMessages.VehicleMessage result = buildPartial();
 508         if (!result.isInitialized()) {
 509           throw newUninitializedMessageException(
 510             result).asInvalidProtocolBufferException();
 511         }
 512         return result;
 513       }
 514
 515       public com.openxc.BinaryMessages.VehicleMessage buildPartial() {
 516         com.openxc.BinaryMessages.VehicleMessage result = new com.openxc.BinaryMessages.VehicleMessage(this);
 517         int from_bitField0_ = bitField0_;
 518         int to_bitField0_ = 0;
 519         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
 520           to_bitField0_ |= 0x00000001;
 521         }
 522         result.type_ = type_;
 523         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
 524           to_bitField0_ |= 0x00000002;
 525         }
 526         if (canMessageBuilder_ == null) {
 527           result.canMessage_ = canMessage_;
 528         } else {
 529           result.canMessage_ = canMessageBuilder_.build();
 530         }
 531         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
 532           to_bitField0_ |= 0x00000004;
 533         }
 534         if (simpleMessageBuilder_ == null) {
 535           result.simpleMessage_ = simpleMessage_;
 536         } else {
 537           result.simpleMessage_ = simpleMessageBuilder_.build();
 538         }
 539         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
 540           to_bitField0_ |= 0x00000008;
 541         }
 542         if (diagnosticResponseBuilder_ == null) {
 543           result.diagnosticResponse_ = diagnosticResponse_;
 544         } else {
 545           result.diagnosticResponse_ = diagnosticResponseBuilder_.build();
 546         }
 547         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
 548           to_bitField0_ |= 0x00000010;
 549         }
 550         if (controlCommandBuilder_ == null) {
 551           result.controlCommand_ = controlCommand_;
 552         } else {
 553           result.controlCommand_ = controlCommandBuilder_.build();
 554         }
 555         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
 556           to_bitField0_ |= 0x00000020;
 557         }
 558         if (commandResponseBuilder_ == null) {
 559           result.commandResponse_ = commandResponse_;
 560         } else {
 561           result.commandResponse_ = commandResponseBuilder_.build();
 562         }
 563         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
 564           to_bitField0_ |= 0x00000040;
 565         }
 566         result.uptime_ = uptime_;
 567         result.bitField0_ = to_bitField0_;
 568         onBuilt();
 569         return result;
 570       }
 571
 572       public Builder mergeFrom(com.google.protobuf.Message other) {
 573         if (other instanceof com.openxc.BinaryMessages.VehicleMessage) {
 574           return mergeFrom((com.openxc.BinaryMessages.VehicleMessage)other);
 575         } else {
 576           super.mergeFrom(other);
 577           return this;
 578         }
 579       }
 580
 581       public Builder mergeFrom(com.openxc.BinaryMessages.VehicleMessage other) {
 582         if (other == com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance()) return this;
 583         if (other.hasType()) {
 584           setType(other.getType());
 585         }
 586         if (other.hasCanMessage()) {
 587           mergeCanMessage(other.getCanMessage());
 588         }
 589         if (other.hasSimpleMessage()) {
 590           mergeSimpleMessage(other.getSimpleMessage());
 591         }
 592         if (other.hasDiagnosticResponse()) {
 593           mergeDiagnosticResponse(other.getDiagnosticResponse());
 594         }
 595         if (other.hasControlCommand()) {
 596           mergeControlCommand(other.getControlCommand());
 597         }
 598         if (other.hasCommandResponse()) {
 599           mergeCommandResponse(other.getCommandResponse());
 600         }
 601         if (other.hasUptime()) {
 602           setUptime(other.getUptime());
 603         }
 604         this.mergeUnknownFields(other.getUnknownFields());
 605         return this;
 606       }
 607
 608       public final boolean isInitialized() {
 609         return true;
 610       }
 611
 612       public Builder mergeFrom(
 613           com.google.protobuf.CodedInputStream input,
 614           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 615           throws java.io.IOException {
 616         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
 617           com.google.protobuf.UnknownFieldSet.newBuilder(
 618             this.getUnknownFields());
 619         while (true) {
 620           int tag = input.readTag();
 621           switch (tag) {
 622             case 0:
 623               this.setUnknownFields(unknownFields.build());
 624               onChanged();
 625               return this;
 626             default: {
 627               if (!parseUnknownField(input, unknownFields,
 628                                      extensionRegistry, tag)) {
 629                 this.setUnknownFields(unknownFields.build());
 630                 onChanged();
 631                 return this;
 632               }
 633               break;
 634             }
 635             case 8: {
 636               int rawValue = input.readEnum();
 637               com.openxc.BinaryMessages.VehicleMessage.Type value = com.openxc.BinaryMessages.VehicleMessage.Type.valueOf(rawValue);
 638               if (value == null) {
 639                 unknownFields.mergeVarintField(1, rawValue);
 640               } else {
 641                 bitField0_ |= 0x00000001;
 642                 type_ = value;
 643               }
 644               break;
 645             }
 646             case 18: {
 647               com.openxc.BinaryMessages.CanMessage.Builder subBuilder = com.openxc.BinaryMessages.CanMessage.newBuilder();
 648               if (hasCanMessage()) {
 649                 subBuilder.mergeFrom(getCanMessage());
 650               }
 651               input.readMessage(subBuilder, extensionRegistry);
 652               setCanMessage(subBuilder.buildPartial());
 653               break;
 654             }
 655             case 26: {
 656               com.openxc.BinaryMessages.SimpleMessage.Builder subBuilder = com.openxc.BinaryMessages.SimpleMessage.newBuilder();
 657               if (hasSimpleMessage()) {
 658                 subBuilder.mergeFrom(getSimpleMessage());
 659               }
 660               input.readMessage(subBuilder, extensionRegistry);
 661               setSimpleMessage(subBuilder.buildPartial());
 662               break;
 663             }
 664             case 34: {
 665               com.openxc.BinaryMessages.DiagnosticResponse.Builder subBuilder = com.openxc.BinaryMessages.DiagnosticResponse.newBuilder();
 666               if (hasDiagnosticResponse()) {
 667                 subBuilder.mergeFrom(getDiagnosticResponse());
 668               }
 669               input.readMessage(subBuilder, extensionRegistry);
 670               setDiagnosticResponse(subBuilder.buildPartial());
 671               break;
 672             }
 673             case 42: {
 674               com.openxc.BinaryMessages.ControlCommand.Builder subBuilder = com.openxc.BinaryMessages.ControlCommand.newBuilder();
 675               if (hasControlCommand()) {
 676                 subBuilder.mergeFrom(getControlCommand());
 677               }
 678               input.readMessage(subBuilder, extensionRegistry);
 679               setControlCommand(subBuilder.buildPartial());
 680               break;
 681             }
 682             case 50: {
 683               com.openxc.BinaryMessages.CommandResponse.Builder subBuilder = com.openxc.BinaryMessages.CommandResponse.newBuilder();
 684               if (hasCommandResponse()) {
 685                 subBuilder.mergeFrom(getCommandResponse());
 686               }
 687               input.readMessage(subBuilder, extensionRegistry);
 688               setCommandResponse(subBuilder.buildPartial());
 689               break;
 690             }
 691             case 56: {
 692               bitField0_ |= 0x00000040;
 693               uptime_ = input.readUInt32();
 694               break;
 695             }
 696           }
 697         }
 698       }
 699
 700       private int bitField0_;
 701
 702       // optional .openxc.VehicleMessage.Type type = 1;
 703       private com.openxc.BinaryMessages.VehicleMessage.Type type_ = com.openxc.BinaryMessages.VehicleMessage.Type.CAN;
 704       public boolean hasType() {
 705         return ((bitField0_ & 0x00000001) == 0x00000001);
 706       }
 707       public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
 708         return type_;
 709       }
 710       public Builder setType(com.openxc.BinaryMessages.VehicleMessage.Type value) {
 711         if (value == null) {
 712           throw new NullPointerException();
 713         }
 714         bitField0_ |= 0x00000001;
 715         type_ = value;
 716         onChanged();
 717         return this;
 718       }
 719       public Builder clearType() {
 720         bitField0_ = (bitField0_ & ~0x00000001);
 721         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.CAN;
 722         onChanged();
 723         return this;
 724       }
 725
 726       // optional .openxc.CanMessage can_message = 2;
 727       private com.openxc.BinaryMessages.CanMessage canMessage_ = com.openxc.BinaryMessages.CanMessage.getDefaultInstance();
 728       private com.google.protobuf.SingleFieldBuilder<
 729           com.openxc.BinaryMessages.CanMessage, com.openxc.BinaryMessages.CanMessage.Builder, com.openxc.BinaryMessages.CanMessageOrBuilder> canMessageBuilder_;
 730       public boolean hasCanMessage() {
 731         return ((bitField0_ & 0x00000002) == 0x00000002);
 732       }
 733       public com.openxc.BinaryMessages.CanMessage getCanMessage() {
 734         if (canMessageBuilder_ == null) {
 735           return canMessage_;
 736         } else {
 737           return canMessageBuilder_.getMessage();
 738         }
 739       }
 740       public Builder setCanMessage(com.openxc.BinaryMessages.CanMessage value) {
 741         if (canMessageBuilder_ == null) {
 742           if (value == null) {
 743             throw new NullPointerException();
 744           }
 745           canMessage_ = value;
 746           onChanged();
 747         } else {
 748           canMessageBuilder_.setMessage(value);
 749         }
 750         bitField0_ |= 0x00000002;
 751         return this;
 752       }
 753       public Builder setCanMessage(
 754           com.openxc.BinaryMessages.CanMessage.Builder builderForValue) {
 755         if (canMessageBuilder_ == null) {
 756           canMessage_ = builderForValue.build();
 757           onChanged();
 758         } else {
 759           canMessageBuilder_.setMessage(builderForValue.build());
 760         }
 761         bitField0_ |= 0x00000002;
 762         return this;
 763       }
 764       public Builder mergeCanMessage(com.openxc.BinaryMessages.CanMessage value) {
 765         if (canMessageBuilder_ == null) {
 766           if (((bitField0_ & 0x00000002) == 0x00000002) &&
 767               canMessage_ != com.openxc.BinaryMessages.CanMessage.getDefaultInstance()) {
 768             canMessage_ =
 769               com.openxc.BinaryMessages.CanMessage.newBuilder(canMessage_).mergeFrom(value).buildPartial();
 770           } else {
 771             canMessage_ = value;
 772           }
 773           onChanged();
 774         } else {
 775           canMessageBuilder_.mergeFrom(value);
 776         }
 777         bitField0_ |= 0x00000002;
 778         return this;
 779       }
 780       public Builder clearCanMessage() {
 781         if (canMessageBuilder_ == null) {
 782           canMessage_ = com.openxc.BinaryMessages.CanMessage.getDefaultInstance();
 783           onChanged();
 784         } else {
 785           canMessageBuilder_.clear();
 786         }
 787         bitField0_ = (bitField0_ & ~0x00000002);
 788         return this;
 789       }
 790       public com.openxc.BinaryMessages.CanMessage.Builder getCanMessageBuilder() {
 791         bitField0_ |= 0x00000002;
 792         onChanged();
 793         return getCanMessageFieldBuilder().getBuilder();
 794       }
 795       public com.openxc.BinaryMessages.CanMessageOrBuilder getCanMessageOrBuilder() {
 796         if (canMessageBuilder_ != null) {
 797           return canMessageBuilder_.getMessageOrBuilder();
 798         } else {
 799           return canMessage_;
 800         }
 801       }
 802       private com.google.protobuf.SingleFieldBuilder<
 803           com.openxc.BinaryMessages.CanMessage, com.openxc.BinaryMessages.CanMessage.Builder, com.openxc.BinaryMessages.CanMessageOrBuilder>
 804           getCanMessageFieldBuilder() {
 805         if (canMessageBuilder_ == null) {
 806           canMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
 807               com.openxc.BinaryMessages.CanMessage, com.openxc.BinaryMessages.CanMessage.Builder, com.openxc.BinaryMessages.CanMessageOrBuilder>(
 808                   canMessage_,
 809                   getParentForChildren(),
 810                   isClean());
 811           canMessage_ = null;
 812         }
 813         return canMessageBuilder_;
 814       }
 815
 816       // optional .openxc.SimpleMessage simple_message = 3;
 817       private com.openxc.BinaryMessages.SimpleMessage simpleMessage_ = com.openxc.BinaryMessages.SimpleMessage.getDefaultInstance();
 818       private com.google.protobuf.SingleFieldBuilder<
 819           com.openxc.BinaryMessages.SimpleMessage, com.openxc.BinaryMessages.SimpleMessage.Builder, com.openxc.BinaryMessages.SimpleMessageOrBuilder> simpleMessageBuilder_;
 820       public boolean hasSimpleMessage() {
 821         return ((bitField0_ & 0x00000004) == 0x00000004);
 822       }
 823       public com.openxc.BinaryMessages.SimpleMessage getSimpleMessage() {
 824         if (simpleMessageBuilder_ == null) {
 825           return simpleMessage_;
 826         } else {
 827           return simpleMessageBuilder_.getMessage();
 828         }
 829       }
 830       public Builder setSimpleMessage(com.openxc.BinaryMessages.SimpleMessage value) {
 831         if (simpleMessageBuilder_ == null) {
 832           if (value == null) {
 833             throw new NullPointerException();
 834           }
 835           simpleMessage_ = value;
 836           onChanged();
 837         } else {
 838           simpleMessageBuilder_.setMessage(value);
 839         }
 840         bitField0_ |= 0x00000004;
 841         return this;
 842       }
 843       public Builder setSimpleMessage(
 844           com.openxc.BinaryMessages.SimpleMessage.Builder builderForValue) {
 845         if (simpleMessageBuilder_ == null) {
 846           simpleMessage_ = builderForValue.build();
 847           onChanged();
 848         } else {
 849           simpleMessageBuilder_.setMessage(builderForValue.build());
 850         }
 851         bitField0_ |= 0x00000004;
 852         return this;
 853       }
 854       public Builder mergeSimpleMessage(com.openxc.BinaryMessages.SimpleMessage value) {
 855         if (simpleMessageBuilder_ == null) {
 856           if (((bitField0_ & 0x00000004) == 0x00000004) &&
 857               simpleMessage_ != com.openxc.BinaryMessages.SimpleMessage.getDefaultInstance()) {
 858             simpleMessage_ =
 859               com.openxc.BinaryMessages.SimpleMessage.newBuilder(simpleMessage_).mergeFrom(value).buildPartial();
 860           } else {
 861             simpleMessage_ = value;
 862           }
 863           onChanged();
 864         } else {
 865           simpleMessageBuilder_.mergeFrom(value);
 866         }
 867         bitField0_ |= 0x00000004;
 868         return this;
 869       }
 870       public Builder clearSimpleMessage() {
 871         if (simpleMessageBuilder_ == null) {
 872           simpleMessage_ = com.openxc.BinaryMessages.SimpleMessage.getDefaultInstance();
 873           onChanged();
 874         } else {
 875           simpleMessageBuilder_.clear();
 876         }
 877         bitField0_ = (bitField0_ & ~0x00000004);
 878         return this;
 879       }
 880       public com.openxc.BinaryMessages.SimpleMessage.Builder getSimpleMessageBuilder() {
 881         bitField0_ |= 0x00000004;
 882         onChanged();
 883         return getSimpleMessageFieldBuilder().getBuilder();
 884       }
 885       public com.openxc.BinaryMessages.SimpleMessageOrBuilder getSimpleMessageOrBuilder() {
 886         if (simpleMessageBuilder_ != null) {
 887           return simpleMessageBuilder_.getMessageOrBuilder();
 888         } else {
 889           return simpleMessage_;
 890         }
 891       }
 892       private com.google.protobuf.SingleFieldBuilder<
 893           com.openxc.BinaryMessages.SimpleMessage, com.openxc.BinaryMessages.SimpleMessage.Builder, com.openxc.BinaryMessages.SimpleMessageOrBuilder>
 894           getSimpleMessageFieldBuilder() {
 895         if (simpleMessageBuilder_ == null) {
 896           simpleMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
 897               com.openxc.BinaryMessages.SimpleMessage, com.openxc.BinaryMessages.SimpleMessage.Builder, com.openxc.BinaryMessages.SimpleMessageOrBuilder>(
 898                   simpleMessage_,
 899                   getParentForChildren(),
 900                   isClean());
 901           simpleMessage_ = null;
 902         }
 903         return simpleMessageBuilder_;
 904       }
 905
 906       // optional .openxc.DiagnosticResponse diagnostic_response = 4;
 907       private com.openxc.BinaryMessages.DiagnosticResponse diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
 908       private com.google.protobuf.SingleFieldBuilder<
 909           com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder> diagnosticResponseBuilder_;
 910       public boolean hasDiagnosticResponse() {
 911         return ((bitField0_ & 0x00000008) == 0x00000008);
 912       }
 913       public com.openxc.BinaryMessages.DiagnosticResponse getDiagnosticResponse() {
 914         if (diagnosticResponseBuilder_ == null) {
 915           return diagnosticResponse_;
 916         } else {
 917           return diagnosticResponseBuilder_.getMessage();
 918         }
 919       }
 920       public Builder setDiagnosticResponse(com.openxc.BinaryMessages.DiagnosticResponse value) {
 921         if (diagnosticResponseBuilder_ == null) {
 922           if (value == null) {
 923             throw new NullPointerException();
 924           }
 925           diagnosticResponse_ = value;
 926           onChanged();
 927         } else {
 928           diagnosticResponseBuilder_.setMessage(value);
 929         }
 930         bitField0_ |= 0x00000008;
 931         return this;
 932       }
 933       public Builder setDiagnosticResponse(
 934           com.openxc.BinaryMessages.DiagnosticResponse.Builder builderForValue) {
 935         if (diagnosticResponseBuilder_ == null) {
 936           diagnosticResponse_ = builderForValue.build();
 937           onChanged();
 938         } else {
 939           diagnosticResponseBuilder_.setMessage(builderForValue.build());
 940         }
 941         bitField0_ |= 0x00000008;
 942         return this;
 943       }
 944       public Builder mergeDiagnosticResponse(com.openxc.BinaryMessages.DiagnosticResponse value) {
 945         if (diagnosticResponseBuilder_ == null) {
 946           if (((bitField0_ & 0x00000008) == 0x00000008) &&
 947               diagnosticResponse_ != com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance()) {
 948             diagnosticResponse_ =
 949               com.openxc.BinaryMessages.DiagnosticResponse.newBuilder(diagnosticResponse_).mergeFrom(value).buildPartial();
 950           } else {
 951             diagnosticResponse_ = value;
 952           }
 953           onChanged();
 954         } else {
 955           diagnosticResponseBuilder_.mergeFrom(value);
 956         }
 957         bitField0_ |= 0x00000008;
 958         return this;
 959       }
 960       public Builder clearDiagnosticResponse() {
 961         if (diagnosticResponseBuilder_ == null) {
 962           diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
 963           onChanged();
 964         } else {
 965           diagnosticResponseBuilder_.clear();
 966         }
 967         bitField0_ = (bitField0_ & ~0x00000008);
 968         return this;
 969       }
 970       public com.openxc.BinaryMessages.DiagnosticResponse.Builder getDiagnosticResponseBuilder() {
 971         bitField0_ |= 0x00000008;
 972         onChanged();
 973         return getDiagnosticResponseFieldBuilder().getBuilder();
 974       }
 975       public com.openxc.BinaryMessages.DiagnosticResponseOrBuilder getDiagnosticResponseOrBuilder() {
 976         if (diagnosticResponseBuilder_ != null) {
 977           return diagnosticResponseBuilder_.getMessageOrBuilder();
 978         } else {
 979           return diagnosticResponse_;
 980         }
 981       }
 982       private com.google.protobuf.SingleFieldBuilder<
 983           com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder>
 984           getDiagnosticResponseFieldBuilder() {
 985         if (diagnosticResponseBuilder_ == null) {
 986           diagnosticResponseBuilder_ = new com.google.protobuf.SingleFieldBuilder<
 987               com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder>(
 988                   diagnosticResponse_,
 989                   getParentForChildren(),
 990                   isClean());
 991           diagnosticResponse_ = null;
 992         }
 993         return diagnosticResponseBuilder_;
 994       }
 995
 996       // optional .openxc.ControlCommand control_command = 5;
 997       private com.openxc.BinaryMessages.ControlCommand controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
 998       private com.google.protobuf.SingleFieldBuilder<
 999           com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder> controlCommandBuilder_;
1000       public boolean hasControlCommand() {
1001         return ((bitField0_ & 0x00000010) == 0x00000010);
1002       }
1003       public com.openxc.BinaryMessages.ControlCommand getControlCommand() {
1004         if (controlCommandBuilder_ == null) {
1005           return controlCommand_;
1006         } else {
1007           return controlCommandBuilder_.getMessage();
1008         }
1009       }
1010       public Builder setControlCommand(com.openxc.BinaryMessages.ControlCommand value) {
1011         if (controlCommandBuilder_ == null) {
1012           if (value == null) {
1013             throw new NullPointerException();
1014           }
1015           controlCommand_ = value;
1016           onChanged();
1017         } else {
1018           controlCommandBuilder_.setMessage(value);
1019         }
1020         bitField0_ |= 0x00000010;
1021         return this;
1022       }
1023       public Builder setControlCommand(
1024           com.openxc.BinaryMessages.ControlCommand.Builder builderForValue) {
1025         if (controlCommandBuilder_ == null) {
1026           controlCommand_ = builderForValue.build();
1027           onChanged();
1028         } else {
1029           controlCommandBuilder_.setMessage(builderForValue.build());
1030         }
1031         bitField0_ |= 0x00000010;
1032         return this;
1033       }
1034       public Builder mergeControlCommand(com.openxc.BinaryMessages.ControlCommand value) {
1035         if (controlCommandBuilder_ == null) {
1036           if (((bitField0_ & 0x00000010) == 0x00000010) &&
1037               controlCommand_ != com.openxc.BinaryMessages.ControlCommand.getDefaultInstance()) {
1038             controlCommand_ =
1039               com.openxc.BinaryMessages.ControlCommand.newBuilder(controlCommand_).mergeFrom(value).buildPartial();
1040           } else {
1041             controlCommand_ = value;
1042           }
1043           onChanged();
1044         } else {
1045           controlCommandBuilder_.mergeFrom(value);
1046         }
1047         bitField0_ |= 0x00000010;
1048         return this;
1049       }
1050       public Builder clearControlCommand() {
1051         if (controlCommandBuilder_ == null) {
1052           controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
1053           onChanged();
1054         } else {
1055           controlCommandBuilder_.clear();
1056         }
1057         bitField0_ = (bitField0_ & ~0x00000010);
1058         return this;
1059       }
1060       public com.openxc.BinaryMessages.ControlCommand.Builder getControlCommandBuilder() {
1061         bitField0_ |= 0x00000010;
1062         onChanged();
1063         return getControlCommandFieldBuilder().getBuilder();
1064       }
1065       public com.openxc.BinaryMessages.ControlCommandOrBuilder getControlCommandOrBuilder() {
1066         if (controlCommandBuilder_ != null) {
1067           return controlCommandBuilder_.getMessageOrBuilder();
1068         } else {
1069           return controlCommand_;
1070         }
1071       }
1072       private com.google.protobuf.SingleFieldBuilder<
1073           com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder>
1074           getControlCommandFieldBuilder() {
1075         if (controlCommandBuilder_ == null) {
1076           controlCommandBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1077               com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder>(
1078                   controlCommand_,
1079                   getParentForChildren(),
1080                   isClean());
1081           controlCommand_ = null;
1082         }
1083         return controlCommandBuilder_;
1084       }
1085
1086       // optional .openxc.CommandResponse command_response = 6;
1087       private com.openxc.BinaryMessages.CommandResponse commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
1088       private com.google.protobuf.SingleFieldBuilder<
1089           com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder> commandResponseBuilder_;
1090       public boolean hasCommandResponse() {
1091         return ((bitField0_ & 0x00000020) == 0x00000020);
1092       }
1093       public com.openxc.BinaryMessages.CommandResponse getCommandResponse() {
1094         if (commandResponseBuilder_ == null) {
1095           return commandResponse_;
1096         } else {
1097           return commandResponseBuilder_.getMessage();
1098         }
1099       }
1100       public Builder setCommandResponse(com.openxc.BinaryMessages.CommandResponse value) {
1101         if (commandResponseBuilder_ == null) {
1102           if (value == null) {
1103             throw new NullPointerException();
1104           }
1105           commandResponse_ = value;
1106           onChanged();
1107         } else {
1108           commandResponseBuilder_.setMessage(value);
1109         }
1110         bitField0_ |= 0x00000020;
1111         return this;
1112       }
1113       public Builder setCommandResponse(
1114           com.openxc.BinaryMessages.CommandResponse.Builder builderForValue) {
1115         if (commandResponseBuilder_ == null) {
1116           commandResponse_ = builderForValue.build();
1117           onChanged();
1118         } else {
1119           commandResponseBuilder_.setMessage(builderForValue.build());
1120         }
1121         bitField0_ |= 0x00000020;
1122         return this;
1123       }
1124       public Builder mergeCommandResponse(com.openxc.BinaryMessages.CommandResponse value) {
1125         if (commandResponseBuilder_ == null) {
1126           if (((bitField0_ & 0x00000020) == 0x00000020) &&
1127               commandResponse_ != com.openxc.BinaryMessages.CommandResponse.getDefaultInstance()) {
1128             commandResponse_ =
1129               com.openxc.BinaryMessages.CommandResponse.newBuilder(commandResponse_).mergeFrom(value).buildPartial();
1130           } else {
1131             commandResponse_ = value;
1132           }
1133           onChanged();
1134         } else {
1135           commandResponseBuilder_.mergeFrom(value);
1136         }
1137         bitField0_ |= 0x00000020;
1138         return this;
1139       }
1140       public Builder clearCommandResponse() {
1141         if (commandResponseBuilder_ == null) {
1142           commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
1143           onChanged();
1144         } else {
1145           commandResponseBuilder_.clear();
1146         }
1147         bitField0_ = (bitField0_ & ~0x00000020);
1148         return this;
1149       }
1150       public com.openxc.BinaryMessages.CommandResponse.Builder getCommandResponseBuilder() {
1151         bitField0_ |= 0x00000020;
1152         onChanged();
1153         return getCommandResponseFieldBuilder().getBuilder();
1154       }
1155       public com.openxc.BinaryMessages.CommandResponseOrBuilder getCommandResponseOrBuilder() {
1156         if (commandResponseBuilder_ != null) {
1157           return commandResponseBuilder_.getMessageOrBuilder();
1158         } else {
1159           return commandResponse_;
1160         }
1161       }
1162       private com.google.protobuf.SingleFieldBuilder<
1163           com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder>
1164           getCommandResponseFieldBuilder() {
1165         if (commandResponseBuilder_ == null) {
1166           commandResponseBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1167               com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder>(
1168                   commandResponse_,
1169                   getParentForChildren(),
1170                   isClean());
1171           commandResponse_ = null;
1172         }
1173         return commandResponseBuilder_;
1174       }
1175
1176       // optional uint32 uptime = 7;
1177       private int uptime_ ;
1178       public boolean hasUptime() {
1179         return ((bitField0_ & 0x00000040) == 0x00000040);
1180       }
1181       public int getUptime() {
1182         return uptime_;
1183       }
1184       public Builder setUptime(int value) {
1185         bitField0_ |= 0x00000040;
1186         uptime_ = value;
1187         onChanged();
1188         return this;
1189       }
1190       public Builder clearUptime() {
1191         bitField0_ = (bitField0_ & ~0x00000040);
1192         uptime_ = 0;
1193         onChanged();
1194         return this;
1195       }
1196
1197       // @@protoc_insertion_point(builder_scope:openxc.VehicleMessage)
1198     }
1199
1200     static {
1201       defaultInstance = new VehicleMessage(true);
1202       defaultInstance.initFields();
1203     }
1204
1205     // @@protoc_insertion_point(class_scope:openxc.VehicleMessage)
1206   }
1207
1208   public interface CanMessageOrBuilder
1209       extends com.google.protobuf.MessageOrBuilder {
1210
1211     // optional int32 bus = 1;
1212     boolean hasBus();
1213     int getBus();
1214
1215     // optional uint32 id = 2;
1216     boolean hasId();
1217     int getId();
1218
1219     // optional bytes data = 3;
1220     boolean hasData();
1221     com.google.protobuf.ByteString getData();
1222
1223     // optional .openxc.CanMessage.FrameFormat frame_format = 4;
1224     boolean hasFrameFormat();
1225     com.openxc.BinaryMessages.CanMessage.FrameFormat getFrameFormat();
1226   }
1227   public static final class CanMessage extends
1228       com.google.protobuf.GeneratedMessage
1229       implements CanMessageOrBuilder {
1230     // Use CanMessage.newBuilder() to construct.
1231     private CanMessage(Builder builder) {
1232       super(builder);
1233     }
1234     private CanMessage(boolean noInit) {}
1235
1236     private static final CanMessage defaultInstance;
1237     public static CanMessage getDefaultInstance() {
1238       return defaultInstance;
1239     }
1240
1241     public CanMessage getDefaultInstanceForType() {
1242       return defaultInstance;
1243     }
1244
1245     public static final com.google.protobuf.Descriptors.Descriptor
1246         getDescriptor() {
1247       return com.openxc.BinaryMessages.internal_static_openxc_CanMessage_descriptor;
1248     }
1249
1250     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1251         internalGetFieldAccessorTable() {
1252       return com.openxc.BinaryMessages.internal_static_openxc_CanMessage_fieldAccessorTable;
1253     }
1254
1255     public enum FrameFormat
1256         implements com.google.protobuf.ProtocolMessageEnum {
1257       STANDARD(0, 1),
1258       EXTENDED(1, 2),
1259       ;
1260
1261       public static final int STANDARD_VALUE = 1;
1262       public static final int EXTENDED_VALUE = 2;
1263
1264
1265       public final int getNumber() { return value; }
1266
1267       public static FrameFormat valueOf(int value) {
1268         switch (value) {
1269           case 1: return STANDARD;
1270           case 2: return EXTENDED;
1271           default: return null;
1272         }
1273       }
1274
1275       public static com.google.protobuf.Internal.EnumLiteMap<FrameFormat>
1276           internalGetValueMap() {
1277         return internalValueMap;
1278       }
1279       private static com.google.protobuf.Internal.EnumLiteMap<FrameFormat>
1280           internalValueMap =
1281             new com.google.protobuf.Internal.EnumLiteMap<FrameFormat>() {
1282               public FrameFormat findValueByNumber(int number) {
1283                 return FrameFormat.valueOf(number);
1284               }
1285             };
1286
1287       public final com.google.protobuf.Descriptors.EnumValueDescriptor
1288           getValueDescriptor() {
1289         return getDescriptor().getValues().get(index);
1290       }
1291       public final com.google.protobuf.Descriptors.EnumDescriptor
1292           getDescriptorForType() {
1293         return getDescriptor();
1294       }
1295       public static final com.google.protobuf.Descriptors.EnumDescriptor
1296           getDescriptor() {
1297         return com.openxc.BinaryMessages.CanMessage.getDescriptor().getEnumTypes().get(0);
1298       }
1299
1300       private static final FrameFormat[] VALUES = {
1301         STANDARD, EXTENDED,
1302       };
1303
1304       public static FrameFormat valueOf(
1305           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
1306         if (desc.getType() != getDescriptor()) {
1307           throw new java.lang.IllegalArgumentException(
1308             "EnumValueDescriptor is not for this type.");
1309         }
1310         return VALUES[desc.getIndex()];
1311       }
1312
1313       private final int index;
1314       private final int value;
1315
1316       private FrameFormat(int index, int value) {
1317         this.index = index;
1318         this.value = value;
1319       }
1320
1321       // @@protoc_insertion_point(enum_scope:openxc.CanMessage.FrameFormat)
1322     }
1323
1324     private int bitField0_;
1325     // optional int32 bus = 1;
1326     public static final int BUS_FIELD_NUMBER = 1;
1327     private int bus_;
1328     public boolean hasBus() {
1329       return ((bitField0_ & 0x00000001) == 0x00000001);
1330     }
1331     public int getBus() {
1332       return bus_;
1333     }
1334
1335     // optional uint32 id = 2;
1336     public static final int ID_FIELD_NUMBER = 2;
1337     private int id_;
1338     public boolean hasId() {
1339       return ((bitField0_ & 0x00000002) == 0x00000002);
1340     }
1341     public int getId() {
1342       return id_;
1343     }
1344
1345     // optional bytes data = 3;
1346     public static final int DATA_FIELD_NUMBER = 3;
1347     private com.google.protobuf.ByteString data_;
1348     public boolean hasData() {
1349       return ((bitField0_ & 0x00000004) == 0x00000004);
1350     }
1351     public com.google.protobuf.ByteString getData() {
1352       return data_;
1353     }
1354
1355     // optional .openxc.CanMessage.FrameFormat frame_format = 4;
1356     public static final int FRAME_FORMAT_FIELD_NUMBER = 4;
1357     private com.openxc.BinaryMessages.CanMessage.FrameFormat frameFormat_;
1358     public boolean hasFrameFormat() {
1359       return ((bitField0_ & 0x00000008) == 0x00000008);
1360     }
1361     public com.openxc.BinaryMessages.CanMessage.FrameFormat getFrameFormat() {
1362       return frameFormat_;
1363     }
1364
1365     private void initFields() {
1366       bus_ = 0;
1367       id_ = 0;
1368       data_ = com.google.protobuf.ByteString.EMPTY;
1369       frameFormat_ = com.openxc.BinaryMessages.CanMessage.FrameFormat.STANDARD;
1370     }
1371     private byte memoizedIsInitialized = -1;
1372     public final boolean isInitialized() {
1373       byte isInitialized = memoizedIsInitialized;
1374       if (isInitialized != -1) return isInitialized == 1;
1375
1376       memoizedIsInitialized = 1;
1377       return true;
1378     }
1379
1380     public void writeTo(com.google.protobuf.CodedOutputStream output)
1381                         throws java.io.IOException {
1382       getSerializedSize();
1383       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1384         output.writeInt32(1, bus_);
1385       }
1386       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1387         output.writeUInt32(2, id_);
1388       }
1389       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1390         output.writeBytes(3, data_);
1391       }
1392       if (((bitField0_ & 0x00000008) == 0x00000008)) {
1393         output.writeEnum(4, frameFormat_.getNumber());
1394       }
1395       getUnknownFields().writeTo(output);
1396     }
1397
1398     private int memoizedSerializedSize = -1;
1399     public int getSerializedSize() {
1400       int size = memoizedSerializedSize;
1401       if (size != -1) return size;
1402
1403       size = 0;
1404       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1405         size += com.google.protobuf.CodedOutputStream
1406           .computeInt32Size(1, bus_);
1407       }
1408       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1409         size += com.google.protobuf.CodedOutputStream
1410           .computeUInt32Size(2, id_);
1411       }
1412       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1413         size += com.google.protobuf.CodedOutputStream
1414           .computeBytesSize(3, data_);
1415       }
1416       if (((bitField0_ & 0x00000008) == 0x00000008)) {
1417         size += com.google.protobuf.CodedOutputStream
1418           .computeEnumSize(4, frameFormat_.getNumber());
1419       }
1420       size += getUnknownFields().getSerializedSize();
1421       memoizedSerializedSize = size;
1422       return size;
1423     }
1424
1425     private static final long serialVersionUID = 0L;
1426     @java.lang.Override
1427     protected java.lang.Object writeReplace()
1428         throws java.io.ObjectStreamException {
1429       return super.writeReplace();
1430     }
1431
1432     public static com.openxc.BinaryMessages.CanMessage parseFrom(
1433         com.google.protobuf.ByteString data)
1434         throws com.google.protobuf.InvalidProtocolBufferException {
1435       return newBuilder().mergeFrom(data).buildParsed();
1436     }
1437     public static com.openxc.BinaryMessages.CanMessage parseFrom(
1438         com.google.protobuf.ByteString data,
1439         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1440         throws com.google.protobuf.InvalidProtocolBufferException {
1441       return newBuilder().mergeFrom(data, extensionRegistry)
1442                .buildParsed();
1443     }
1444     public static com.openxc.BinaryMessages.CanMessage parseFrom(byte[] data)
1445         throws com.google.protobuf.InvalidProtocolBufferException {
1446       return newBuilder().mergeFrom(data).buildParsed();
1447     }
1448     public static com.openxc.BinaryMessages.CanMessage parseFrom(
1449         byte[] data,
1450         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1451         throws com.google.protobuf.InvalidProtocolBufferException {
1452       return newBuilder().mergeFrom(data, extensionRegistry)
1453                .buildParsed();
1454     }
1455     public static com.openxc.BinaryMessages.CanMessage parseFrom(java.io.InputStream input)
1456         throws java.io.IOException {
1457       return newBuilder().mergeFrom(input).buildParsed();
1458     }
1459     public static com.openxc.BinaryMessages.CanMessage parseFrom(
1460         java.io.InputStream input,
1461         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1462         throws java.io.IOException {
1463       return newBuilder().mergeFrom(input, extensionRegistry)
1464                .buildParsed();
1465     }
1466     public static com.openxc.BinaryMessages.CanMessage parseDelimitedFrom(java.io.InputStream input)
1467         throws java.io.IOException {
1468       Builder builder = newBuilder();
1469       if (builder.mergeDelimitedFrom(input)) {
1470         return builder.buildParsed();
1471       } else {
1472         return null;
1473       }
1474     }
1475     public static com.openxc.BinaryMessages.CanMessage parseDelimitedFrom(
1476         java.io.InputStream input,
1477         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1478         throws java.io.IOException {
1479       Builder builder = newBuilder();
1480       if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
1481         return builder.buildParsed();
1482       } else {
1483         return null;
1484       }
1485     }
1486     public static com.openxc.BinaryMessages.CanMessage parseFrom(
1487         com.google.protobuf.CodedInputStream input)
1488         throws java.io.IOException {
1489       return newBuilder().mergeFrom(input).buildParsed();
1490     }
1491     public static com.openxc.BinaryMessages.CanMessage parseFrom(
1492         com.google.protobuf.CodedInputStream input,
1493         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1494         throws java.io.IOException {
1495       return newBuilder().mergeFrom(input, extensionRegistry)
1496                .buildParsed();
1497     }
1498
1499     public static Builder newBuilder() { return Builder.create(); }
1500     public Builder newBuilderForType() { return newBuilder(); }
1501     public static Builder newBuilder(com.openxc.BinaryMessages.CanMessage prototype) {
1502       return newBuilder().mergeFrom(prototype);
1503     }
1504     public Builder toBuilder() { return newBuilder(this); }
1505
1506     @java.lang.Override
1507     protected Builder newBuilderForType(
1508         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1509       Builder builder = new Builder(parent);
1510       return builder;
1511     }
1512     public static final class Builder extends
1513         com.google.protobuf.GeneratedMessage.Builder<Builder>
1514        implements com.openxc.BinaryMessages.CanMessageOrBuilder {
1515       public static final com.google.protobuf.Descriptors.Descriptor
1516           getDescriptor() {
1517         return com.openxc.BinaryMessages.internal_static_openxc_CanMessage_descriptor;
1518       }
1519
1520       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1521           internalGetFieldAccessorTable() {
1522         return com.openxc.BinaryMessages.internal_static_openxc_CanMessage_fieldAccessorTable;
1523       }
1524
1525       // Construct using com.openxc.BinaryMessages.CanMessage.newBuilder()
1526       private Builder() {
1527         maybeForceBuilderInitialization();
1528       }
1529
1530       private Builder(BuilderParent parent) {
1531         super(parent);
1532         maybeForceBuilderInitialization();
1533       }
1534       private void maybeForceBuilderInitialization() {
1535         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
1536         }
1537       }
1538       private static Builder create() {
1539         return new Builder();
1540       }
1541
1542       public Builder clear() {
1543         super.clear();
1544         bus_ = 0;
1545         bitField0_ = (bitField0_ & ~0x00000001);
1546         id_ = 0;
1547         bitField0_ = (bitField0_ & ~0x00000002);
1548         data_ = com.google.protobuf.ByteString.EMPTY;
1549         bitField0_ = (bitField0_ & ~0x00000004);
1550         frameFormat_ = com.openxc.BinaryMessages.CanMessage.FrameFormat.STANDARD;
1551         bitField0_ = (bitField0_ & ~0x00000008);
1552         return this;
1553       }
1554
1555       public Builder clone() {
1556         return create().mergeFrom(buildPartial());
1557       }
1558
1559       public com.google.protobuf.Descriptors.Descriptor
1560           getDescriptorForType() {
1561         return com.openxc.BinaryMessages.CanMessage.getDescriptor();
1562       }
1563
1564       public com.openxc.BinaryMessages.CanMessage getDefaultInstanceForType() {
1565         return com.openxc.BinaryMessages.CanMessage.getDefaultInstance();
1566       }
1567
1568       public com.openxc.BinaryMessages.CanMessage build() {
1569         com.openxc.BinaryMessages.CanMessage result = buildPartial();
1570         if (!result.isInitialized()) {
1571           throw newUninitializedMessageException(result);
1572         }
1573         return result;
1574       }
1575
1576       private com.openxc.BinaryMessages.CanMessage buildParsed()
1577           throws com.google.protobuf.InvalidProtocolBufferException {
1578         com.openxc.BinaryMessages.CanMessage result = buildPartial();
1579         if (!result.isInitialized()) {
1580           throw newUninitializedMessageException(
1581             result).asInvalidProtocolBufferException();
1582         }
1583         return result;
1584       }
1585
1586       public com.openxc.BinaryMessages.CanMessage buildPartial() {
1587         com.openxc.BinaryMessages.CanMessage result = new com.openxc.BinaryMessages.CanMessage(this);
1588         int from_bitField0_ = bitField0_;
1589         int to_bitField0_ = 0;
1590         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
1591           to_bitField0_ |= 0x00000001;
1592         }
1593         result.bus_ = bus_;
1594         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
1595           to_bitField0_ |= 0x00000002;
1596         }
1597         result.id_ = id_;
1598         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
1599           to_bitField0_ |= 0x00000004;
1600         }
1601         result.data_ = data_;
1602         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
1603           to_bitField0_ |= 0x00000008;
1604         }
1605         result.frameFormat_ = frameFormat_;
1606         result.bitField0_ = to_bitField0_;
1607         onBuilt();
1608         return result;
1609       }
1610
1611       public Builder mergeFrom(com.google.protobuf.Message other) {
1612         if (other instanceof com.openxc.BinaryMessages.CanMessage) {
1613           return mergeFrom((com.openxc.BinaryMessages.CanMessage)other);
1614         } else {
1615           super.mergeFrom(other);
1616           return this;
1617         }
1618       }
1619
1620       public Builder mergeFrom(com.openxc.BinaryMessages.CanMessage other) {
1621         if (other == com.openxc.BinaryMessages.CanMessage.getDefaultInstance()) return this;
1622         if (other.hasBus()) {
1623           setBus(other.getBus());
1624         }
1625         if (other.hasId()) {
1626           setId(other.getId());
1627         }
1628         if (other.hasData()) {
1629           setData(other.getData());
1630         }
1631         if (other.hasFrameFormat()) {
1632           setFrameFormat(other.getFrameFormat());
1633         }
1634         this.mergeUnknownFields(other.getUnknownFields());
1635         return this;
1636       }
1637
1638       public final boolean isInitialized() {
1639         return true;
1640       }
1641
1642       public Builder mergeFrom(
1643           com.google.protobuf.CodedInputStream input,
1644           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1645           throws java.io.IOException {
1646         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
1647           com.google.protobuf.UnknownFieldSet.newBuilder(
1648             this.getUnknownFields());
1649         while (true) {
1650           int tag = input.readTag();
1651           switch (tag) {
1652             case 0:
1653               this.setUnknownFields(unknownFields.build());
1654               onChanged();
1655               return this;
1656             default: {
1657               if (!parseUnknownField(input, unknownFields,
1658                                      extensionRegistry, tag)) {
1659                 this.setUnknownFields(unknownFields.build());
1660                 onChanged();
1661                 return this;
1662               }
1663               break;
1664             }
1665             case 8: {
1666               bitField0_ |= 0x00000001;
1667               bus_ = input.readInt32();
1668               break;
1669             }
1670             case 16: {
1671               bitField0_ |= 0x00000002;
1672               id_ = input.readUInt32();
1673               break;
1674             }
1675             case 26: {
1676               bitField0_ |= 0x00000004;
1677               data_ = input.readBytes();
1678               break;
1679             }
1680             case 32: {
1681               int rawValue = input.readEnum();
1682               com.openxc.BinaryMessages.CanMessage.FrameFormat value = com.openxc.BinaryMessages.CanMessage.FrameFormat.valueOf(rawValue);
1683               if (value == null) {
1684                 unknownFields.mergeVarintField(4, rawValue);
1685               } else {
1686                 bitField0_ |= 0x00000008;
1687                 frameFormat_ = value;
1688               }
1689               break;
1690             }
1691           }
1692         }
1693       }
1694
1695       private int bitField0_;
1696
1697       // optional int32 bus = 1;
1698       private int bus_ ;
1699       public boolean hasBus() {
1700         return ((bitField0_ & 0x00000001) == 0x00000001);
1701       }
1702       public int getBus() {
1703         return bus_;
1704       }
1705       public Builder setBus(int value) {
1706         bitField0_ |= 0x00000001;
1707         bus_ = value;
1708         onChanged();
1709         return this;
1710       }
1711       public Builder clearBus() {
1712         bitField0_ = (bitField0_ & ~0x00000001);
1713         bus_ = 0;
1714         onChanged();
1715         return this;
1716       }
1717
1718       // optional uint32 id = 2;
1719       private int id_ ;
1720       public boolean hasId() {
1721         return ((bitField0_ & 0x00000002) == 0x00000002);
1722       }
1723       public int getId() {
1724         return id_;
1725       }
1726       public Builder setId(int value) {
1727         bitField0_ |= 0x00000002;
1728         id_ = value;
1729         onChanged();
1730         return this;
1731       }
1732       public Builder clearId() {
1733         bitField0_ = (bitField0_ & ~0x00000002);
1734         id_ = 0;
1735         onChanged();
1736         return this;
1737       }
1738
1739       // optional bytes data = 3;
1740       private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
1741       public boolean hasData() {
1742         return ((bitField0_ & 0x00000004) == 0x00000004);
1743       }
1744       public com.google.protobuf.ByteString getData() {
1745         return data_;
1746       }
1747       public Builder setData(com.google.protobuf.ByteString value) {
1748         if (value == null) {
1749     throw new NullPointerException();
1750   }
1751   bitField0_ |= 0x00000004;
1752         data_ = value;
1753         onChanged();
1754         return this;
1755       }
1756       public Builder clearData() {
1757         bitField0_ = (bitField0_ & ~0x00000004);
1758         data_ = getDefaultInstance().getData();
1759         onChanged();
1760         return this;
1761       }
1762
1763       // optional .openxc.CanMessage.FrameFormat frame_format = 4;
1764       private com.openxc.BinaryMessages.CanMessage.FrameFormat frameFormat_ = com.openxc.BinaryMessages.CanMessage.FrameFormat.STANDARD;
1765       public boolean hasFrameFormat() {
1766         return ((bitField0_ & 0x00000008) == 0x00000008);
1767       }
1768       public com.openxc.BinaryMessages.CanMessage.FrameFormat getFrameFormat() {
1769         return frameFormat_;
1770       }
1771       public Builder setFrameFormat(com.openxc.BinaryMessages.CanMessage.FrameFormat value) {
1772         if (value == null) {
1773           throw new NullPointerException();
1774         }
1775         bitField0_ |= 0x00000008;
1776         frameFormat_ = value;
1777         onChanged();
1778         return this;
1779       }
1780       public Builder clearFrameFormat() {
1781         bitField0_ = (bitField0_ & ~0x00000008);
1782         frameFormat_ = com.openxc.BinaryMessages.CanMessage.FrameFormat.STANDARD;
1783         onChanged();
1784         return this;
1785       }
1786
1787       // @@protoc_insertion_point(builder_scope:openxc.CanMessage)
1788     }
1789
1790     static {
1791       defaultInstance = new CanMessage(true);
1792       defaultInstance.initFields();
1793     }
1794
1795     // @@protoc_insertion_point(class_scope:openxc.CanMessage)
1796   }
1797
1798   public interface ControlCommandOrBuilder
1799       extends com.google.protobuf.MessageOrBuilder {
1800
1801     // optional .openxc.ControlCommand.Type type = 1;
1802     boolean hasType();
1803     com.openxc.BinaryMessages.ControlCommand.Type getType();
1804
1805     // optional .openxc.DiagnosticControlCommand diagnostic_request = 2;
1806     boolean hasDiagnosticRequest();
1807     com.openxc.BinaryMessages.DiagnosticControlCommand getDiagnosticRequest();
1808     com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder getDiagnosticRequestOrBuilder();
1809
1810     // optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;
1811     boolean hasPassthroughModeRequest();
1812     com.openxc.BinaryMessages.PassthroughModeControlCommand getPassthroughModeRequest();
1813     com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder getPassthroughModeRequestOrBuilder();
1814
1815     // optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;
1816     boolean hasAcceptanceFilterBypassCommand();
1817     com.openxc.BinaryMessages.AcceptanceFilterBypassCommand getAcceptanceFilterBypassCommand();
1818     com.openxc.BinaryMessages.AcceptanceFilterBypassCommandOrBuilder getAcceptanceFilterBypassCommandOrBuilder();
1819
1820     // optional .openxc.PayloadFormatCommand payload_format_command = 5;
1821     boolean hasPayloadFormatCommand();
1822     com.openxc.BinaryMessages.PayloadFormatCommand getPayloadFormatCommand();
1823     com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder getPayloadFormatCommandOrBuilder();
1824
1825     // optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;
1826     boolean hasPredefinedObd2RequestsCommand();
1827     com.openxc.BinaryMessages.PredefinedObd2RequestsCommand getPredefinedObd2RequestsCommand();
1828     com.openxc.BinaryMessages.PredefinedObd2RequestsCommandOrBuilder getPredefinedObd2RequestsCommandOrBuilder();
1829
1830     // optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;
1831     boolean hasModemConfigurationCommand();
1832     com.openxc.BinaryMessages.ModemConfigurationCommand getModemConfigurationCommand();
1833     com.openxc.BinaryMessages.ModemConfigurationCommandOrBuilder getModemConfigurationCommandOrBuilder();
1834   }
1835   public static final class ControlCommand extends
1836       com.google.protobuf.GeneratedMessage
1837       implements ControlCommandOrBuilder {
1838     // Use ControlCommand.newBuilder() to construct.
1839     private ControlCommand(Builder builder) {
1840       super(builder);
1841     }
1842     private ControlCommand(boolean noInit) {}
1843
1844     private static final ControlCommand defaultInstance;
1845     public static ControlCommand getDefaultInstance() {
1846       return defaultInstance;
1847     }
1848
1849     public ControlCommand getDefaultInstanceForType() {
1850       return defaultInstance;
1851     }
1852
1853     public static final com.google.protobuf.Descriptors.Descriptor
1854         getDescriptor() {
1855       return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
1856     }
1857
1858     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1859         internalGetFieldAccessorTable() {
1860       return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_fieldAccessorTable;
1861     }
1862
1863     public enum Type
1864         implements com.google.protobuf.ProtocolMessageEnum {
1865       VERSION(0, 1),
1866       DEVICE_ID(1, 2),
1867       DIAGNOSTIC(2, 3),
1868       PASSTHROUGH(3, 4),
1869       ACCEPTANCE_FILTER_BYPASS(4, 5),
1870       PAYLOAD_FORMAT(5, 6),
1871       PREDEFINED_OBD2_REQUESTS(6, 7),
1872       MODEM_CONFIGURATION(7, 8),
1873       ;
1874
1875       public static final int VERSION_VALUE = 1;
1876       public static final int DEVICE_ID_VALUE = 2;
1877       public static final int DIAGNOSTIC_VALUE = 3;
1878       public static final int PASSTHROUGH_VALUE = 4;
1879       public static final int ACCEPTANCE_FILTER_BYPASS_VALUE = 5;
1880       public static final int PAYLOAD_FORMAT_VALUE = 6;
1881       public static final int PREDEFINED_OBD2_REQUESTS_VALUE = 7;
1882       public static final int MODEM_CONFIGURATION_VALUE = 8;
1883
1884
1885       public final int getNumber() { return value; }
1886
1887       public static Type valueOf(int value) {
1888         switch (value) {
1889           case 1: return VERSION;
1890           case 2: return DEVICE_ID;
1891           case 3: return DIAGNOSTIC;
1892           case 4: return PASSTHROUGH;
1893           case 5: return ACCEPTANCE_FILTER_BYPASS;
1894           case 6: return PAYLOAD_FORMAT;
1895           case 7: return PREDEFINED_OBD2_REQUESTS;
1896           case 8: return MODEM_CONFIGURATION;
1897           default: return null;
1898         }
1899       }
1900
1901       public static com.google.protobuf.Internal.EnumLiteMap<Type>
1902           internalGetValueMap() {
1903         return internalValueMap;
1904       }
1905       private static com.google.protobuf.Internal.EnumLiteMap<Type>
1906           internalValueMap =
1907             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
1908               public Type findValueByNumber(int number) {
1909                 return Type.valueOf(number);
1910               }
1911             };
1912
1913       public final com.google.protobuf.Descriptors.EnumValueDescriptor
1914           getValueDescriptor() {
1915         return getDescriptor().getValues().get(index);
1916       }
1917       public final com.google.protobuf.Descriptors.EnumDescriptor
1918           getDescriptorForType() {
1919         return getDescriptor();
1920       }
1921       public static final com.google.protobuf.Descriptors.EnumDescriptor
1922           getDescriptor() {
1923         return com.openxc.BinaryMessages.ControlCommand.getDescriptor().getEnumTypes().get(0);
1924       }
1925
1926       private static final Type[] VALUES = {
1927         VERSION, DEVICE_ID, DIAGNOSTIC, PASSTHROUGH, ACCEPTANCE_FILTER_BYPASS, PAYLOAD_FORMAT, PREDEFINED_OBD2_REQUESTS, MODEM_CONFIGURATION,
1928       };
1929
1930       public static Type valueOf(
1931           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
1932         if (desc.getType() != getDescriptor()) {
1933           throw new java.lang.IllegalArgumentException(
1934             "EnumValueDescriptor is not for this type.");
1935         }
1936         return VALUES[desc.getIndex()];
1937       }
1938
1939       private final int index;
1940       private final int value;
1941
1942       private Type(int index, int value) {
1943         this.index = index;
1944         this.value = value;
1945       }
1946
1947       // @@protoc_insertion_point(enum_scope:openxc.ControlCommand.Type)
1948     }
1949
1950     private int bitField0_;
1951     // optional .openxc.ControlCommand.Type type = 1;
1952     public static final int TYPE_FIELD_NUMBER = 1;
1953     private com.openxc.BinaryMessages.ControlCommand.Type type_;
1954     public boolean hasType() {
1955       return ((bitField0_ & 0x00000001) == 0x00000001);
1956     }
1957     public com.openxc.BinaryMessages.ControlCommand.Type getType() {
1958       return type_;
1959     }
1960
1961     // optional .openxc.DiagnosticControlCommand diagnostic_request = 2;
1962     public static final int DIAGNOSTIC_REQUEST_FIELD_NUMBER = 2;
1963     private com.openxc.BinaryMessages.DiagnosticControlCommand diagnosticRequest_;
1964     public boolean hasDiagnosticRequest() {
1965       return ((bitField0_ & 0x00000002) == 0x00000002);
1966     }
1967     public com.openxc.BinaryMessages.DiagnosticControlCommand getDiagnosticRequest() {
1968       return diagnosticRequest_;
1969     }
1970     public com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder getDiagnosticRequestOrBuilder() {
1971       return diagnosticRequest_;
1972     }
1973
1974     // optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;
1975     public static final int PASSTHROUGH_MODE_REQUEST_FIELD_NUMBER = 3;
1976     private com.openxc.BinaryMessages.PassthroughModeControlCommand passthroughModeRequest_;
1977     public boolean hasPassthroughModeRequest() {
1978       return ((bitField0_ & 0x00000004) == 0x00000004);
1979     }
1980     public com.openxc.BinaryMessages.PassthroughModeControlCommand getPassthroughModeRequest() {
1981       return passthroughModeRequest_;
1982     }
1983     public com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder getPassthroughModeRequestOrBuilder() {
1984       return passthroughModeRequest_;
1985     }
1986
1987     // optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;
1988     public static final int ACCEPTANCE_FILTER_BYPASS_COMMAND_FIELD_NUMBER = 4;
1989     private com.openxc.BinaryMessages.AcceptanceFilterBypassCommand acceptanceFilterBypassCommand_;
1990     public boolean hasAcceptanceFilterBypassCommand() {
1991       return ((bitField0_ & 0x00000008) == 0x00000008);
1992     }
1993     public com.openxc.BinaryMessages.AcceptanceFilterBypassCommand getAcceptanceFilterBypassCommand() {
1994       return acceptanceFilterBypassCommand_;
1995     }
1996     public com.openxc.BinaryMessages.AcceptanceFilterBypassCommandOrBuilder getAcceptanceFilterBypassCommandOrBuilder() {
1997       return acceptanceFilterBypassCommand_;
1998     }
1999
2000     // optional .openxc.PayloadFormatCommand payload_format_command = 5;
2001     public static final int PAYLOAD_FORMAT_COMMAND_FIELD_NUMBER = 5;
2002     private com.openxc.BinaryMessages.PayloadFormatCommand payloadFormatCommand_;
2003     public boolean hasPayloadFormatCommand() {
2004       return ((bitField0_ & 0x00000010) == 0x00000010);
2005     }
2006     public com.openxc.BinaryMessages.PayloadFormatCommand getPayloadFormatCommand() {
2007       return payloadFormatCommand_;
2008     }
2009     public com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder getPayloadFormatCommandOrBuilder() {
2010       return payloadFormatCommand_;
2011     }
2012
2013     // optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;
2014     public static final int PREDEFINED_OBD2_REQUESTS_COMMAND_FIELD_NUMBER = 6;
2015     private com.openxc.BinaryMessages.PredefinedObd2RequestsCommand predefinedObd2RequestsCommand_;
2016     public boolean hasPredefinedObd2RequestsCommand() {
2017       return ((bitField0_ & 0x00000020) == 0x00000020);
2018     }
2019     public com.openxc.BinaryMessages.PredefinedObd2RequestsCommand getPredefinedObd2RequestsCommand() {
2020       return predefinedObd2RequestsCommand_;
2021     }
2022     public com.openxc.BinaryMessages.PredefinedObd2RequestsCommandOrBuilder getPredefinedObd2RequestsCommandOrBuilder() {
2023       return predefinedObd2RequestsCommand_;
2024     }
2025
2026     // optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;
2027     public static final int MODEM_CONFIGURATION_COMMAND_FIELD_NUMBER = 7;
2028     private com.openxc.BinaryMessages.ModemConfigurationCommand modemConfigurationCommand_;
2029     public boolean hasModemConfigurationCommand() {
2030       return ((bitField0_ & 0x00000040) == 0x00000040);
2031     }
2032     public com.openxc.BinaryMessages.ModemConfigurationCommand getModemConfigurationCommand() {
2033       return modemConfigurationCommand_;
2034     }
2035     public com.openxc.BinaryMessages.ModemConfigurationCommandOrBuilder getModemConfigurationCommandOrBuilder() {
2036       return modemConfigurationCommand_;
2037     }
2038
2039     private void initFields() {
2040       type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2041       diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance();
2042       passthroughModeRequest_ = com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance();
2043       acceptanceFilterBypassCommand_ = com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.getDefaultInstance();
2044       payloadFormatCommand_ = com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance();
2045       predefinedObd2RequestsCommand_ = com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.getDefaultInstance();
2046       modemConfigurationCommand_ = com.openxc.BinaryMessages.ModemConfigurationCommand.getDefaultInstance();
2047     }
2048     private byte memoizedIsInitialized = -1;
2049     public final boolean isInitialized() {
2050       byte isInitialized = memoizedIsInitialized;
2051       if (isInitialized != -1) return isInitialized == 1;
2052
2053       memoizedIsInitialized = 1;
2054       return true;
2055     }
2056
2057     public void writeTo(com.google.protobuf.CodedOutputStream output)
2058                         throws java.io.IOException {
2059       getSerializedSize();
2060       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2061         output.writeEnum(1, type_.getNumber());
2062       }
2063       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2064         output.writeMessage(2, diagnosticRequest_);
2065       }
2066       if (((bitField0_ & 0x00000004) == 0x00000004)) {
2067         output.writeMessage(3, passthroughModeRequest_);
2068       }
2069       if (((bitField0_ & 0x00000008) == 0x00000008)) {
2070         output.writeMessage(4, acceptanceFilterBypassCommand_);
2071       }
2072       if (((bitField0_ & 0x00000010) == 0x00000010)) {
2073         output.writeMessage(5, payloadFormatCommand_);
2074       }
2075       if (((bitField0_ & 0x00000020) == 0x00000020)) {
2076         output.writeMessage(6, predefinedObd2RequestsCommand_);
2077       }
2078       if (((bitField0_ & 0x00000040) == 0x00000040)) {
2079         output.writeMessage(7, modemConfigurationCommand_);
2080       }
2081       getUnknownFields().writeTo(output);
2082     }
2083
2084     private int memoizedSerializedSize = -1;
2085     public int getSerializedSize() {
2086       int size = memoizedSerializedSize;
2087       if (size != -1) return size;
2088
2089       size = 0;
2090       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2091         size += com.google.protobuf.CodedOutputStream
2092           .computeEnumSize(1, type_.getNumber());
2093       }
2094       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2095         size += com.google.protobuf.CodedOutputStream
2096           .computeMessageSize(2, diagnosticRequest_);
2097       }
2098       if (((bitField0_ & 0x00000004) == 0x00000004)) {
2099         size += com.google.protobuf.CodedOutputStream
2100           .computeMessageSize(3, passthroughModeRequest_);
2101       }
2102       if (((bitField0_ & 0x00000008) == 0x00000008)) {
2103         size += com.google.protobuf.CodedOutputStream
2104           .computeMessageSize(4, acceptanceFilterBypassCommand_);
2105       }
2106       if (((bitField0_ & 0x00000010) == 0x00000010)) {
2107         size += com.google.protobuf.CodedOutputStream
2108           .computeMessageSize(5, payloadFormatCommand_);
2109       }
2110       if (((bitField0_ & 0x00000020) == 0x00000020)) {
2111         size += com.google.protobuf.CodedOutputStream
2112           .computeMessageSize(6, predefinedObd2RequestsCommand_);
2113       }
2114       if (((bitField0_ & 0x00000040) == 0x00000040)) {
2115         size += com.google.protobuf.CodedOutputStream
2116           .computeMessageSize(7, modemConfigurationCommand_);
2117       }
2118       size += getUnknownFields().getSerializedSize();
2119       memoizedSerializedSize = size;
2120       return size;
2121     }
2122
2123     private static final long serialVersionUID = 0L;
2124     @java.lang.Override
2125     protected java.lang.Object writeReplace()
2126         throws java.io.ObjectStreamException {
2127       return super.writeReplace();
2128     }
2129
2130     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2131         com.google.protobuf.ByteString data)
2132         throws com.google.protobuf.InvalidProtocolBufferException {
2133       return newBuilder().mergeFrom(data).buildParsed();
2134     }
2135     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2136         com.google.protobuf.ByteString data,
2137         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2138         throws com.google.protobuf.InvalidProtocolBufferException {
2139       return newBuilder().mergeFrom(data, extensionRegistry)
2140                .buildParsed();
2141     }
2142     public static com.openxc.BinaryMessages.ControlCommand parseFrom(byte[] data)
2143         throws com.google.protobuf.InvalidProtocolBufferException {
2144       return newBuilder().mergeFrom(data).buildParsed();
2145     }
2146     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2147         byte[] data,
2148         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2149         throws com.google.protobuf.InvalidProtocolBufferException {
2150       return newBuilder().mergeFrom(data, extensionRegistry)
2151                .buildParsed();
2152     }
2153     public static com.openxc.BinaryMessages.ControlCommand parseFrom(java.io.InputStream input)
2154         throws java.io.IOException {
2155       return newBuilder().mergeFrom(input).buildParsed();
2156     }
2157     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2158         java.io.InputStream input,
2159         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2160         throws java.io.IOException {
2161       return newBuilder().mergeFrom(input, extensionRegistry)
2162                .buildParsed();
2163     }
2164     public static com.openxc.BinaryMessages.ControlCommand parseDelimitedFrom(java.io.InputStream input)
2165         throws java.io.IOException {
2166       Builder builder = newBuilder();
2167       if (builder.mergeDelimitedFrom(input)) {
2168         return builder.buildParsed();
2169       } else {
2170         return null;
2171       }
2172     }
2173     public static com.openxc.BinaryMessages.ControlCommand parseDelimitedFrom(
2174         java.io.InputStream input,
2175         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2176         throws java.io.IOException {
2177       Builder builder = newBuilder();
2178       if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
2179         return builder.buildParsed();
2180       } else {
2181         return null;
2182       }
2183     }
2184     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2185         com.google.protobuf.CodedInputStream input)
2186         throws java.io.IOException {
2187       return newBuilder().mergeFrom(input).buildParsed();
2188     }
2189     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2190         com.google.protobuf.CodedInputStream input,
2191         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2192         throws java.io.IOException {
2193       return newBuilder().mergeFrom(input, extensionRegistry)
2194                .buildParsed();
2195     }
2196
2197     public static Builder newBuilder() { return Builder.create(); }
2198     public Builder newBuilderForType() { return newBuilder(); }
2199     public static Builder newBuilder(com.openxc.BinaryMessages.ControlCommand prototype) {
2200       return newBuilder().mergeFrom(prototype);
2201     }
2202     public Builder toBuilder() { return newBuilder(this); }
2203
2204     @java.lang.Override
2205     protected Builder newBuilderForType(
2206         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2207       Builder builder = new Builder(parent);
2208       return builder;
2209     }
2210     public static final class Builder extends
2211         com.google.protobuf.GeneratedMessage.Builder<Builder>
2212        implements com.openxc.BinaryMessages.ControlCommandOrBuilder {
2213       public static final com.google.protobuf.Descriptors.Descriptor
2214           getDescriptor() {
2215         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
2216       }
2217
2218       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2219           internalGetFieldAccessorTable() {
2220         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_fieldAccessorTable;
2221       }
2222
2223       // Construct using com.openxc.BinaryMessages.ControlCommand.newBuilder()
2224       private Builder() {
2225         maybeForceBuilderInitialization();
2226       }
2227
2228       private Builder(BuilderParent parent) {
2229         super(parent);
2230         maybeForceBuilderInitialization();
2231       }
2232       private void maybeForceBuilderInitialization() {
2233         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2234           getDiagnosticRequestFieldBuilder();
2235           getPassthroughModeRequestFieldBuilder();
2236           getAcceptanceFilterBypassCommandFieldBuilder();
2237           getPayloadFormatCommandFieldBuilder();
2238           getPredefinedObd2RequestsCommandFieldBuilder();
2239           getModemConfigurationCommandFieldBuilder();
2240         }
2241       }
2242       private static Builder create() {
2243         return new Builder();
2244       }
2245
2246       public Builder clear() {
2247         super.clear();
2248         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2249         bitField0_ = (bitField0_ & ~0x00000001);
2250         if (diagnosticRequestBuilder_ == null) {
2251           diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance();
2252         } else {
2253           diagnosticRequestBuilder_.clear();
2254         }
2255         bitField0_ = (bitField0_ & ~0x00000002);
2256         if (passthroughModeRequestBuilder_ == null) {
2257           passthroughModeRequest_ = com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance();
2258         } else {
2259           passthroughModeRequestBuilder_.clear();
2260         }
2261         bitField0_ = (bitField0_ & ~0x00000004);
2262         if (acceptanceFilterBypassCommandBuilder_ == null) {
2263           acceptanceFilterBypassCommand_ = com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.getDefaultInstance();
2264         } else {
2265           acceptanceFilterBypassCommandBuilder_.clear();
2266         }
2267         bitField0_ = (bitField0_ & ~0x00000008);
2268         if (payloadFormatCommandBuilder_ == null) {
2269           payloadFormatCommand_ = com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance();
2270         } else {
2271           payloadFormatCommandBuilder_.clear();
2272         }
2273         bitField0_ = (bitField0_ & ~0x00000010);
2274         if (predefinedObd2RequestsCommandBuilder_ == null) {
2275           predefinedObd2RequestsCommand_ = com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.getDefaultInstance();
2276         } else {
2277           predefinedObd2RequestsCommandBuilder_.clear();
2278         }
2279         bitField0_ = (bitField0_ & ~0x00000020);
2280         if (modemConfigurationCommandBuilder_ == null) {
2281           modemConfigurationCommand_ = com.openxc.BinaryMessages.ModemConfigurationCommand.getDefaultInstance();
2282         } else {
2283           modemConfigurationCommandBuilder_.clear();
2284         }
2285         bitField0_ = (bitField0_ & ~0x00000040);
2286         return this;
2287       }
2288
2289       public Builder clone() {
2290         return create().mergeFrom(buildPartial());
2291       }
2292
2293       public com.google.protobuf.Descriptors.Descriptor
2294           getDescriptorForType() {
2295         return com.openxc.BinaryMessages.ControlCommand.getDescriptor();
2296       }
2297
2298       public com.openxc.BinaryMessages.ControlCommand getDefaultInstanceForType() {
2299         return com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
2300       }
2301
2302       public com.openxc.BinaryMessages.ControlCommand build() {
2303         com.openxc.BinaryMessages.ControlCommand result = buildPartial();
2304         if (!result.isInitialized()) {
2305           throw newUninitializedMessageException(result);
2306         }
2307         return result;
2308       }
2309
2310       private com.openxc.BinaryMessages.ControlCommand buildParsed()
2311           throws com.google.protobuf.InvalidProtocolBufferException {
2312         com.openxc.BinaryMessages.ControlCommand result = buildPartial();
2313         if (!result.isInitialized()) {
2314           throw newUninitializedMessageException(
2315             result).asInvalidProtocolBufferException();
2316         }
2317         return result;
2318       }
2319
2320       public com.openxc.BinaryMessages.ControlCommand buildPartial() {
2321         com.openxc.BinaryMessages.ControlCommand result = new com.openxc.BinaryMessages.ControlCommand(this);
2322         int from_bitField0_ = bitField0_;
2323         int to_bitField0_ = 0;
2324         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
2325           to_bitField0_ |= 0x00000001;
2326         }
2327         result.type_ = type_;
2328         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
2329           to_bitField0_ |= 0x00000002;
2330         }
2331         if (diagnosticRequestBuilder_ == null) {
2332           result.diagnosticRequest_ = diagnosticRequest_;
2333         } else {
2334           result.diagnosticRequest_ = diagnosticRequestBuilder_.build();
2335         }
2336         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
2337           to_bitField0_ |= 0x00000004;
2338         }
2339         if (passthroughModeRequestBuilder_ == null) {
2340           result.passthroughModeRequest_ = passthroughModeRequest_;
2341         } else {
2342           result.passthroughModeRequest_ = passthroughModeRequestBuilder_.build();
2343         }
2344         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
2345           to_bitField0_ |= 0x00000008;
2346         }
2347         if (acceptanceFilterBypassCommandBuilder_ == null) {
2348           result.acceptanceFilterBypassCommand_ = acceptanceFilterBypassCommand_;
2349         } else {
2350           result.acceptanceFilterBypassCommand_ = acceptanceFilterBypassCommandBuilder_.build();
2351         }
2352         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
2353           to_bitField0_ |= 0x00000010;
2354         }
2355         if (payloadFormatCommandBuilder_ == null) {
2356           result.payloadFormatCommand_ = payloadFormatCommand_;
2357         } else {
2358           result.payloadFormatCommand_ = payloadFormatCommandBuilder_.build();
2359         }
2360         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
2361           to_bitField0_ |= 0x00000020;
2362         }
2363         if (predefinedObd2RequestsCommandBuilder_ == null) {
2364           result.predefinedObd2RequestsCommand_ = predefinedObd2RequestsCommand_;
2365         } else {
2366           result.predefinedObd2RequestsCommand_ = predefinedObd2RequestsCommandBuilder_.build();
2367         }
2368         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
2369           to_bitField0_ |= 0x00000040;
2370         }
2371         if (modemConfigurationCommandBuilder_ == null) {
2372           result.modemConfigurationCommand_ = modemConfigurationCommand_;
2373         } else {
2374           result.modemConfigurationCommand_ = modemConfigurationCommandBuilder_.build();
2375         }
2376         result.bitField0_ = to_bitField0_;
2377         onBuilt();
2378         return result;
2379       }
2380
2381       public Builder mergeFrom(com.google.protobuf.Message other) {
2382         if (other instanceof com.openxc.BinaryMessages.ControlCommand) {
2383           return mergeFrom((com.openxc.BinaryMessages.ControlCommand)other);
2384         } else {
2385           super.mergeFrom(other);
2386           return this;
2387         }
2388       }
2389
2390       public Builder mergeFrom(com.openxc.BinaryMessages.ControlCommand other) {
2391         if (other == com.openxc.BinaryMessages.ControlCommand.getDefaultInstance()) return this;
2392         if (other.hasType()) {
2393           setType(other.getType());
2394         }
2395         if (other.hasDiagnosticRequest()) {
2396           mergeDiagnosticRequest(other.getDiagnosticRequest());
2397         }
2398         if (other.hasPassthroughModeRequest()) {
2399           mergePassthroughModeRequest(other.getPassthroughModeRequest());
2400         }
2401         if (other.hasAcceptanceFilterBypassCommand()) {
2402           mergeAcceptanceFilterBypassCommand(other.getAcceptanceFilterBypassCommand());
2403         }
2404         if (other.hasPayloadFormatCommand()) {
2405           mergePayloadFormatCommand(other.getPayloadFormatCommand());
2406         }
2407         if (other.hasPredefinedObd2RequestsCommand()) {
2408           mergePredefinedObd2RequestsCommand(other.getPredefinedObd2RequestsCommand());
2409         }
2410         if (other.hasModemConfigurationCommand()) {
2411           mergeModemConfigurationCommand(other.getModemConfigurationCommand());
2412         }
2413         this.mergeUnknownFields(other.getUnknownFields());
2414         return this;
2415       }
2416
2417       public final boolean isInitialized() {
2418         return true;
2419       }
2420
2421       public Builder mergeFrom(
2422           com.google.protobuf.CodedInputStream input,
2423           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2424           throws java.io.IOException {
2425         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
2426           com.google.protobuf.UnknownFieldSet.newBuilder(
2427             this.getUnknownFields());
2428         while (true) {
2429           int tag = input.readTag();
2430           switch (tag) {
2431             case 0:
2432               this.setUnknownFields(unknownFields.build());
2433               onChanged();
2434               return this;
2435             default: {
2436               if (!parseUnknownField(input, unknownFields,
2437                                      extensionRegistry, tag)) {
2438                 this.setUnknownFields(unknownFields.build());
2439                 onChanged();
2440                 return this;
2441               }
2442               break;
2443             }
2444             case 8: {
2445               int rawValue = input.readEnum();
2446               com.openxc.BinaryMessages.ControlCommand.Type value = com.openxc.BinaryMessages.ControlCommand.Type.valueOf(rawValue);
2447               if (value == null) {
2448                 unknownFields.mergeVarintField(1, rawValue);
2449               } else {
2450                 bitField0_ |= 0x00000001;
2451                 type_ = value;
2452               }
2453               break;
2454             }
2455             case 18: {
2456               com.openxc.BinaryMessages.DiagnosticControlCommand.Builder subBuilder = com.openxc.BinaryMessages.DiagnosticControlCommand.newBuilder();
2457               if (hasDiagnosticRequest()) {
2458                 subBuilder.mergeFrom(getDiagnosticRequest());
2459               }
2460               input.readMessage(subBuilder, extensionRegistry);
2461               setDiagnosticRequest(subBuilder.buildPartial());
2462               break;
2463             }
2464             case 26: {
2465               com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder subBuilder = com.openxc.BinaryMessages.PassthroughModeControlCommand.newBuilder();
2466               if (hasPassthroughModeRequest()) {
2467                 subBuilder.mergeFrom(getPassthroughModeRequest());
2468               }
2469               input.readMessage(subBuilder, extensionRegistry);
2470               setPassthroughModeRequest(subBuilder.buildPartial());
2471               break;
2472             }
2473             case 34: {
2474               com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.Builder subBuilder = com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.newBuilder();
2475               if (hasAcceptanceFilterBypassCommand()) {
2476                 subBuilder.mergeFrom(getAcceptanceFilterBypassCommand());
2477               }
2478               input.readMessage(subBuilder, extensionRegistry);
2479               setAcceptanceFilterBypassCommand(subBuilder.buildPartial());
2480               break;
2481             }
2482             case 42: {
2483               com.openxc.BinaryMessages.PayloadFormatCommand.Builder subBuilder = com.openxc.BinaryMessages.PayloadFormatCommand.newBuilder();
2484               if (hasPayloadFormatCommand()) {
2485                 subBuilder.mergeFrom(getPayloadFormatCommand());
2486               }
2487               input.readMessage(subBuilder, extensionRegistry);
2488               setPayloadFormatCommand(subBuilder.buildPartial());
2489               break;
2490             }
2491             case 50: {
2492               com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.Builder subBuilder = com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.newBuilder();
2493               if (hasPredefinedObd2RequestsCommand()) {
2494                 subBuilder.mergeFrom(getPredefinedObd2RequestsCommand());
2495               }
2496               input.readMessage(subBuilder, extensionRegistry);
2497               setPredefinedObd2RequestsCommand(subBuilder.buildPartial());
2498               break;
2499             }
2500             case 58: {
2501               com.openxc.BinaryMessages.ModemConfigurationCommand.Builder subBuilder = com.openxc.BinaryMessages.ModemConfigurationCommand.newBuilder();
2502               if (hasModemConfigurationCommand()) {
2503                 subBuilder.mergeFrom(getModemConfigurationCommand());
2504               }
2505               input.readMessage(subBuilder, extensionRegistry);
2506               setModemConfigurationCommand(subBuilder.buildPartial());
2507               break;
2508             }
2509           }
2510         }
2511       }
2512
2513       private int bitField0_;
2514
2515       // optional .openxc.ControlCommand.Type type = 1;
2516       private com.openxc.BinaryMessages.ControlCommand.Type type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2517       public boolean hasType() {
2518         return ((bitField0_ & 0x00000001) == 0x00000001);
2519       }
2520       public com.openxc.BinaryMessages.ControlCommand.Type getType() {
2521         return type_;
2522       }
2523       public Builder setType(com.openxc.BinaryMessages.ControlCommand.Type value) {
2524         if (value == null) {
2525           throw new NullPointerException();
2526         }
2527         bitField0_ |= 0x00000001;
2528         type_ = value;
2529         onChanged();
2530         return this;
2531       }
2532       public Builder clearType() {
2533         bitField0_ = (bitField0_ & ~0x00000001);
2534         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2535         onChanged();
2536         return this;
2537       }
2538
2539       // optional .openxc.DiagnosticControlCommand diagnostic_request = 2;
2540       private com.openxc.BinaryMessages.DiagnosticControlCommand diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance();
2541       private com.google.protobuf.SingleFieldBuilder<
2542           com.openxc.BinaryMessages.DiagnosticControlCommand, com.openxc.BinaryMessages.DiagnosticControlCommand.Builder, com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder> diagnosticRequestBuilder_;
2543       public boolean hasDiagnosticRequest() {
2544         return ((bitField0_ & 0x00000002) == 0x00000002);
2545       }
2546       public com.openxc.BinaryMessages.DiagnosticControlCommand getDiagnosticRequest() {
2547         if (diagnosticRequestBuilder_ == null) {
2548           return diagnosticRequest_;
2549         } else {
2550           return diagnosticRequestBuilder_.getMessage();
2551         }
2552       }
2553       public Builder setDiagnosticRequest(com.openxc.BinaryMessages.DiagnosticControlCommand value) {
2554         if (diagnosticRequestBuilder_ == null) {
2555           if (value == null) {
2556             throw new NullPointerException();
2557           }
2558           diagnosticRequest_ = value;
2559           onChanged();
2560         } else {
2561           diagnosticRequestBuilder_.setMessage(value);
2562         }
2563         bitField0_ |= 0x00000002;
2564         return this;
2565       }
2566       public Builder setDiagnosticRequest(
2567           com.openxc.BinaryMessages.DiagnosticControlCommand.Builder builderForValue) {
2568         if (diagnosticRequestBuilder_ == null) {
2569           diagnosticRequest_ = builderForValue.build();
2570           onChanged();
2571         } else {
2572           diagnosticRequestBuilder_.setMessage(builderForValue.build());
2573         }
2574         bitField0_ |= 0x00000002;
2575         return this;
2576       }
2577       public Builder mergeDiagnosticRequest(com.openxc.BinaryMessages.DiagnosticControlCommand value) {
2578         if (diagnosticRequestBuilder_ == null) {
2579           if (((bitField0_ & 0x00000002) == 0x00000002) &&
2580               diagnosticRequest_ != com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance()) {
2581             diagnosticRequest_ =
2582               com.openxc.BinaryMessages.DiagnosticControlCommand.newBuilder(diagnosticRequest_).mergeFrom(value).buildPartial();
2583           } else {
2584             diagnosticRequest_ = value;
2585           }
2586           onChanged();
2587         } else {
2588           diagnosticRequestBuilder_.mergeFrom(value);
2589         }
2590         bitField0_ |= 0x00000002;
2591         return this;
2592       }
2593       public Builder clearDiagnosticRequest() {
2594         if (diagnosticRequestBuilder_ == null) {
2595           diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance();
2596           onChanged();
2597         } else {
2598           diagnosticRequestBuilder_.clear();
2599         }
2600         bitField0_ = (bitField0_ & ~0x00000002);
2601         return this;
2602       }
2603       public com.openxc.BinaryMessages.DiagnosticControlCommand.Builder getDiagnosticRequestBuilder() {
2604         bitField0_ |= 0x00000002;
2605         onChanged();
2606         return getDiagnosticRequestFieldBuilder().getBuilder();
2607       }
2608       public com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder getDiagnosticRequestOrBuilder() {
2609         if (diagnosticRequestBuilder_ != null) {
2610           return diagnosticRequestBuilder_.getMessageOrBuilder();
2611         } else {
2612           return diagnosticRequest_;
2613         }
2614       }
2615       private com.google.protobuf.SingleFieldBuilder<
2616           com.openxc.BinaryMessages.DiagnosticControlCommand, com.openxc.BinaryMessages.DiagnosticControlCommand.Builder, com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder>
2617           getDiagnosticRequestFieldBuilder() {
2618         if (diagnosticRequestBuilder_ == null) {
2619           diagnosticRequestBuilder_ = new com.google.protobuf.SingleFieldBuilder<
2620               com.openxc.BinaryMessages.DiagnosticControlCommand, com.openxc.BinaryMessages.DiagnosticControlCommand.Builder, com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder>(
2621                   diagnosticRequest_,
2622                   getParentForChildren(),
2623                   isClean());
2624           diagnosticRequest_ = null;
2625         }
2626         return diagnosticRequestBuilder_;
2627       }
2628
2629       // optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;
2630       private com.openxc.BinaryMessages.PassthroughModeControlCommand passthroughModeRequest_ = com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance();
2631       private com.google.protobuf.SingleFieldBuilder<
2632           com.openxc.BinaryMessages.PassthroughModeControlCommand, com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder, com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder> passthroughModeRequestBuilder_;
2633       public boolean hasPassthroughModeRequest() {
2634         return ((bitField0_ & 0x00000004) == 0x00000004);
2635       }
2636       public com.openxc.BinaryMessages.PassthroughModeControlCommand getPassthroughModeRequest() {
2637         if (passthroughModeRequestBuilder_ == null) {
2638           return passthroughModeRequest_;
2639         } else {
2640           return passthroughModeRequestBuilder_.getMessage();
2641         }
2642       }
2643       public Builder setPassthroughModeRequest(com.openxc.BinaryMessages.PassthroughModeControlCommand value) {
2644         if (passthroughModeRequestBuilder_ == null) {
2645           if (value == null) {
2646             throw new NullPointerException();
2647           }
2648           passthroughModeRequest_ = value;
2649           onChanged();
2650         } else {
2651           passthroughModeRequestBuilder_.setMessage(value);
2652         }
2653         bitField0_ |= 0x00000004;
2654         return this;
2655       }
2656       public Builder setPassthroughModeRequest(
2657           com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder builderForValue) {
2658         if (passthroughModeRequestBuilder_ == null) {
2659           passthroughModeRequest_ = builderForValue.build();
2660           onChanged();
2661         } else {
2662           passthroughModeRequestBuilder_.setMessage(builderForValue.build());
2663         }
2664         bitField0_ |= 0x00000004;
2665         return this;
2666       }
2667       public Builder mergePassthroughModeRequest(com.openxc.BinaryMessages.PassthroughModeControlCommand value) {
2668         if (passthroughModeRequestBuilder_ == null) {
2669           if (((bitField0_ & 0x00000004) == 0x00000004) &&
2670               passthroughModeRequest_ != com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance()) {
2671             passthroughModeRequest_ =
2672               com.openxc.BinaryMessages.PassthroughModeControlCommand.newBuilder(passthroughModeRequest_).mergeFrom(value).buildPartial();
2673           } else {
2674             passthroughModeRequest_ = value;
2675           }
2676           onChanged();
2677         } else {
2678           passthroughModeRequestBuilder_.mergeFrom(value);
2679         }
2680         bitField0_ |= 0x00000004;
2681         return this;
2682       }
2683       public Builder clearPassthroughModeRequest() {
2684         if (passthroughModeRequestBuilder_ == null) {
2685           passthroughModeRequest_ = com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance();
2686           onChanged();
2687         } else {
2688           passthroughModeRequestBuilder_.clear();
2689         }
2690         bitField0_ = (bitField0_ & ~0x00000004);
2691         return this;
2692       }
2693       public com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder getPassthroughModeRequestBuilder() {
2694         bitField0_ |= 0x00000004;
2695         onChanged();
2696         return getPassthroughModeRequestFieldBuilder().getBuilder();
2697       }
2698       public com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder getPassthroughModeRequestOrBuilder() {
2699         if (passthroughModeRequestBuilder_ != null) {
2700           return passthroughModeRequestBuilder_.getMessageOrBuilder();
2701         } else {
2702           return passthroughModeRequest_;
2703         }
2704       }
2705       private com.google.protobuf.SingleFieldBuilder<
2706           com.openxc.BinaryMessages.PassthroughModeControlCommand, com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder, com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder>
2707           getPassthroughModeRequestFieldBuilder() {
2708         if (passthroughModeRequestBuilder_ == null) {
2709           passthroughModeRequestBuilder_ = new com.google.protobuf.SingleFieldBuilder<
2710               com.openxc.BinaryMessages.PassthroughModeControlCommand, com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder, com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder>(
2711                   passthroughModeRequest_,
2712                   getParentForChildren(),
2713                   isClean());
2714           passthroughModeRequest_ = null;
2715         }
2716         return passthroughModeRequestBuilder_;
2717       }
2718
2719       // optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;
2720       private com.openxc.BinaryMessages.AcceptanceFilterBypassCommand acceptanceFilterBypassCommand_ = com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.getDefaultInstance();
2721       private com.google.protobuf.SingleFieldBuilder<
2722           com.openxc.BinaryMessages.AcceptanceFilterBypassCommand, com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.Builder, com.openxc.BinaryMessages.AcceptanceFilterBypassCommandOrBuilder> acceptanceFilterBypassCommandBuilder_;
2723       public boolean hasAcceptanceFilterBypassCommand() {
2724         return ((bitField0_ & 0x00000008) == 0x00000008);
2725       }
2726       public com.openxc.BinaryMessages.AcceptanceFilterBypassCommand getAcceptanceFilterBypassCommand() {
2727         if (acceptanceFilterBypassCommandBuilder_ == null) {
2728           return acceptanceFilterBypassCommand_;
2729         } else {
2730           return acceptanceFilterBypassCommandBuilder_.getMessage();
2731         }
2732       }
2733       public Builder setAcceptanceFilterBypassCommand(com.openxc.BinaryMessages.AcceptanceFilterBypassCommand value) {
2734         if (acceptanceFilterBypassCommandBuilder_ == null) {
2735           if (value == null) {
2736             throw new NullPointerException();
2737           }
2738           acceptanceFilterBypassCommand_ = value;
2739           onChanged();
2740         } else {
2741           acceptanceFilterBypassCommandBuilder_.setMessage(value);
2742         }
2743         bitField0_ |= 0x00000008;
2744         return this;
2745       }
2746       public Builder setAcceptanceFilterBypassCommand(
2747           com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.Builder builderForValue) {
2748         if (acceptanceFilterBypassCommandBuilder_ == null) {
2749           acceptanceFilterBypassCommand_ = builderForValue.build();
2750           onChanged();
2751         } else {
2752           acceptanceFilterBypassCommandBuilder_.setMessage(builderForValue.build());
2753         }
2754         bitField0_ |= 0x00000008;
2755         return this;
2756       }
2757       public Builder mergeAcceptanceFilterBypassCommand(com.openxc.BinaryMessages.AcceptanceFilterBypassCommand value) {
2758         if (acceptanceFilterBypassCommandBuilder_ == null) {
2759           if (((bitField0_ & 0x00000008) == 0x00000008) &&
2760               acceptanceFilterBypassCommand_ != com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.getDefaultInstance()) {
2761             acceptanceFilterBypassCommand_ =
2762               com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.newBuilder(acceptanceFilterBypassCommand_).mergeFrom(value).buildPartial();
2763           } else {
2764             acceptanceFilterBypassCommand_ = value;
2765           }
2766           onChanged();
2767         } else {
2768           acceptanceFilterBypassCommandBuilder_.mergeFrom(value);
2769         }
2770         bitField0_ |= 0x00000008;
2771         return this;
2772       }
2773       public Builder clearAcceptanceFilterBypassCommand() {
2774         if (acceptanceFilterBypassCommandBuilder_ == null) {
2775           acceptanceFilterBypassCommand_ = com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.getDefaultInstance();
2776           onChanged();
2777         } else {
2778           acceptanceFilterBypassCommandBuilder_.clear();
2779         }
2780         bitField0_ = (bitField0_ & ~0x00000008);
2781         return this;
2782       }
2783       public com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.Builder getAcceptanceFilterBypassCommandBuilder() {
2784         bitField0_ |= 0x00000008;
2785         onChanged();
2786         return getAcceptanceFilterBypassCommandFieldBuilder().getBuilder();
2787       }
2788       public com.openxc.BinaryMessages.AcceptanceFilterBypassCommandOrBuilder getAcceptanceFilterBypassCommandOrBuilder() {
2789         if (acceptanceFilterBypassCommandBuilder_ != null) {
2790           return acceptanceFilterBypassCommandBuilder_.getMessageOrBuilder();
2791         } else {
2792           return acceptanceFilterBypassCommand_;
2793         }
2794       }
2795       private com.google.protobuf.SingleFieldBuilder<
2796           com.openxc.BinaryMessages.AcceptanceFilterBypassCommand, com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.Builder, com.openxc.BinaryMessages.AcceptanceFilterBypassCommandOrBuilder>
2797           getAcceptanceFilterBypassCommandFieldBuilder() {
2798         if (acceptanceFilterBypassCommandBuilder_ == null) {
2799           acceptanceFilterBypassCommandBuilder_ = new com.google.protobuf.SingleFieldBuilder<
2800               com.openxc.BinaryMessages.AcceptanceFilterBypassCommand, com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.Builder, com.openxc.BinaryMessages.AcceptanceFilterBypassCommandOrBuilder>(
2801                   acceptanceFilterBypassCommand_,
2802                   getParentForChildren(),
2803                   isClean());
2804           acceptanceFilterBypassCommand_ = null;
2805         }
2806         return acceptanceFilterBypassCommandBuilder_;
2807       }
2808
2809       // optional .openxc.PayloadFormatCommand payload_format_command = 5;
2810       private com.openxc.BinaryMessages.PayloadFormatCommand payloadFormatCommand_ = com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance();
2811       private com.google.protobuf.SingleFieldBuilder<
2812           com.openxc.BinaryMessages.PayloadFormatCommand, com.openxc.BinaryMessages.PayloadFormatCommand.Builder, com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder> payloadFormatCommandBuilder_;
2813       public boolean hasPayloadFormatCommand() {
2814         return ((bitField0_ & 0x00000010) == 0x00000010);
2815       }
2816       public com.openxc.BinaryMessages.PayloadFormatCommand getPayloadFormatCommand() {
2817         if (payloadFormatCommandBuilder_ == null) {
2818           return payloadFormatCommand_;
2819         } else {
2820           return payloadFormatCommandBuilder_.getMessage();
2821         }
2822       }
2823       public Builder setPayloadFormatCommand(com.openxc.BinaryMessages.PayloadFormatCommand value) {
2824         if (payloadFormatCommandBuilder_ == null) {
2825           if (value == null) {
2826             throw new NullPointerException();
2827           }
2828           payloadFormatCommand_ = value;
2829           onChanged();
2830         } else {
2831           payloadFormatCommandBuilder_.setMessage(value);
2832         }
2833         bitField0_ |= 0x00000010;
2834         return this;
2835       }
2836       public Builder setPayloadFormatCommand(
2837           com.openxc.BinaryMessages.PayloadFormatCommand.Builder builderForValue) {
2838         if (payloadFormatCommandBuilder_ == null) {
2839           payloadFormatCommand_ = builderForValue.build();
2840           onChanged();
2841         } else {
2842           payloadFormatCommandBuilder_.setMessage(builderForValue.build());
2843         }
2844         bitField0_ |= 0x00000010;
2845         return this;
2846       }
2847       public Builder mergePayloadFormatCommand(com.openxc.BinaryMessages.PayloadFormatCommand value) {
2848         if (payloadFormatCommandBuilder_ == null) {
2849           if (((bitField0_ & 0x00000010) == 0x00000010) &&
2850               payloadFormatCommand_ != com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance()) {
2851             payloadFormatCommand_ =
2852               com.openxc.BinaryMessages.PayloadFormatCommand.newBuilder(payloadFormatCommand_).mergeFrom(value).buildPartial();
2853           } else {
2854             payloadFormatCommand_ = value;
2855           }
2856           onChanged();
2857         } else {
2858           payloadFormatCommandBuilder_.mergeFrom(value);
2859         }
2860         bitField0_ |= 0x00000010;
2861         return this;
2862       }
2863       public Builder clearPayloadFormatCommand() {
2864         if (payloadFormatCommandBuilder_ == null) {
2865           payloadFormatCommand_ = com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance();
2866           onChanged();
2867         } else {
2868           payloadFormatCommandBuilder_.clear();
2869         }
2870         bitField0_ = (bitField0_ & ~0x00000010);
2871         return this;
2872       }
2873       public com.openxc.BinaryMessages.PayloadFormatCommand.Builder getPayloadFormatCommandBuilder() {
2874         bitField0_ |= 0x00000010;
2875         onChanged();
2876         return getPayloadFormatCommandFieldBuilder().getBuilder();
2877       }
2878       public com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder getPayloadFormatCommandOrBuilder() {
2879         if (payloadFormatCommandBuilder_ != null) {
2880           return payloadFormatCommandBuilder_.getMessageOrBuilder();
2881         } else {
2882           return payloadFormatCommand_;
2883         }
2884       }
2885       private com.google.protobuf.SingleFieldBuilder<
2886           com.openxc.BinaryMessages.PayloadFormatCommand, com.openxc.BinaryMessages.PayloadFormatCommand.Builder, com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder>
2887           getPayloadFormatCommandFieldBuilder() {
2888         if (payloadFormatCommandBuilder_ == null) {
2889           payloadFormatCommandBuilder_ = new com.google.protobuf.SingleFieldBuilder<
2890               com.openxc.BinaryMessages.PayloadFormatCommand, com.openxc.BinaryMessages.PayloadFormatCommand.Builder, com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder>(
2891                   payloadFormatCommand_,
2892                   getParentForChildren(),
2893                   isClean());
2894           payloadFormatCommand_ = null;
2895         }
2896         return payloadFormatCommandBuilder_;
2897       }
2898
2899       // optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;
2900       private com.openxc.BinaryMessages.PredefinedObd2RequestsCommand predefinedObd2RequestsCommand_ = com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.getDefaultInstance();
2901       private com.google.protobuf.SingleFieldBuilder<
2902           com.openxc.BinaryMessages.PredefinedObd2RequestsCommand, com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.Builder, com.openxc.BinaryMessages.PredefinedObd2RequestsCommandOrBuilder> predefinedObd2RequestsCommandBuilder_;
2903       public boolean hasPredefinedObd2RequestsCommand() {
2904         return ((bitField0_ & 0x00000020) == 0x00000020);
2905       }
2906       public com.openxc.BinaryMessages.PredefinedObd2RequestsCommand getPredefinedObd2RequestsCommand() {
2907         if (predefinedObd2RequestsCommandBuilder_ == null) {
2908           return predefinedObd2RequestsCommand_;
2909         } else {
2910           return predefinedObd2RequestsCommandBuilder_.getMessage();
2911         }
2912       }
2913       public Builder setPredefinedObd2RequestsCommand(com.openxc.BinaryMessages.PredefinedObd2RequestsCommand value) {
2914         if (predefinedObd2RequestsCommandBuilder_ == null) {
2915           if (value == null) {
2916             throw new NullPointerException();
2917           }
2918           predefinedObd2RequestsCommand_ = value;
2919           onChanged();
2920         } else {
2921           predefinedObd2RequestsCommandBuilder_.setMessage(value);
2922         }
2923         bitField0_ |= 0x00000020;
2924         return this;
2925       }
2926       public Builder setPredefinedObd2RequestsCommand(
2927           com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.Builder builderForValue) {
2928         if (predefinedObd2RequestsCommandBuilder_ == null) {
2929           predefinedObd2RequestsCommand_ = builderForValue.build();
2930           onChanged();
2931         } else {
2932           predefinedObd2RequestsCommandBuilder_.setMessage(builderForValue.build());
2933         }
2934         bitField0_ |= 0x00000020;
2935         return this;
2936       }
2937       public Builder mergePredefinedObd2RequestsCommand(com.openxc.BinaryMessages.PredefinedObd2RequestsCommand value) {
2938         if (predefinedObd2RequestsCommandBuilder_ == null) {
2939           if (((bitField0_ & 0x00000020) == 0x00000020) &&
2940               predefinedObd2RequestsCommand_ != com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.getDefaultInstance()) {
2941             predefinedObd2RequestsCommand_ =
2942               com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.newBuilder(predefinedObd2RequestsCommand_).mergeFrom(value).buildPartial();
2943           } else {
2944             predefinedObd2RequestsCommand_ = value;
2945           }
2946           onChanged();
2947         } else {
2948           predefinedObd2RequestsCommandBuilder_.mergeFrom(value);
2949         }
2950         bitField0_ |= 0x00000020;
2951         return this;
2952       }
2953       public Builder clearPredefinedObd2RequestsCommand() {
2954         if (predefinedObd2RequestsCommandBuilder_ == null) {
2955           predefinedObd2RequestsCommand_ = com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.getDefaultInstance();
2956           onChanged();
2957         } else {
2958           predefinedObd2RequestsCommandBuilder_.clear();
2959         }
2960         bitField0_ = (bitField0_ & ~0x00000020);
2961         return this;
2962       }
2963       public com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.Builder getPredefinedObd2RequestsCommandBuilder() {
2964         bitField0_ |= 0x00000020;
2965         onChanged();
2966         return getPredefinedObd2RequestsCommandFieldBuilder().getBuilder();
2967       }
2968       public com.openxc.BinaryMessages.PredefinedObd2RequestsCommandOrBuilder getPredefinedObd2RequestsCommandOrBuilder() {
2969         if (predefinedObd2RequestsCommandBuilder_ != null) {
2970           return predefinedObd2RequestsCommandBuilder_.getMessageOrBuilder();
2971         } else {
2972           return predefinedObd2RequestsCommand_;
2973         }
2974       }
2975       private com.google.protobuf.SingleFieldBuilder<
2976           com.openxc.BinaryMessages.PredefinedObd2RequestsCommand, com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.Builder, com.openxc.BinaryMessages.PredefinedObd2RequestsCommandOrBuilder>
2977           getPredefinedObd2RequestsCommandFieldBuilder() {
2978         if (predefinedObd2RequestsCommandBuilder_ == null) {
2979           predefinedObd2RequestsCommandBuilder_ = new com.google.protobuf.SingleFieldBuilder<
2980               com.openxc.BinaryMessages.PredefinedObd2RequestsCommand, com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.Builder, com.openxc.BinaryMessages.PredefinedObd2RequestsCommandOrBuilder>(
2981                   predefinedObd2RequestsCommand_,
2982                   getParentForChildren(),
2983                   isClean());
2984           predefinedObd2RequestsCommand_ = null;
2985         }
2986         return predefinedObd2RequestsCommandBuilder_;
2987       }
2988
2989       // optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;
2990       private com.openxc.BinaryMessages.ModemConfigurationCommand modemConfigurationCommand_ = com.openxc.BinaryMessages.ModemConfigurationCommand.getDefaultInstance();
2991       private com.google.protobuf.SingleFieldBuilder<
2992           com.openxc.BinaryMessages.ModemConfigurationCommand, com.openxc.BinaryMessages.ModemConfigurationCommand.Builder, com.openxc.BinaryMessages.ModemConfigurationCommandOrBuilder> modemConfigurationCommandBuilder_;
2993       public boolean hasModemConfigurationCommand() {
2994         return ((bitField0_ & 0x00000040) == 0x00000040);
2995       }
2996       public com.openxc.BinaryMessages.ModemConfigurationCommand getModemConfigurationCommand() {
2997         if (modemConfigurationCommandBuilder_ == null) {
2998           return modemConfigurationCommand_;
2999         } else {
3000           return modemConfigurationCommandBuilder_.getMessage();
3001         }
3002       }
3003       public Builder setModemConfigurationCommand(com.openxc.BinaryMessages.ModemConfigurationCommand value) {
3004         if (modemConfigurationCommandBuilder_ == null) {
3005           if (value == null) {
3006             throw new NullPointerException();
3007           }
3008           modemConfigurationCommand_ = value;
3009           onChanged();
3010         } else {
3011           modemConfigurationCommandBuilder_.setMessage(value);
3012         }
3013         bitField0_ |= 0x00000040;
3014         return this;
3015       }
3016       public Builder setModemConfigurationCommand(
3017           com.openxc.BinaryMessages.ModemConfigurationCommand.Builder builderForValue) {
3018         if (modemConfigurationCommandBuilder_ == null) {
3019           modemConfigurationCommand_ = builderForValue.build();
3020           onChanged();
3021         } else {
3022           modemConfigurationCommandBuilder_.setMessage(builderForValue.build());
3023         }
3024         bitField0_ |= 0x00000040;
3025         return this;
3026       }
3027       public Builder mergeModemConfigurationCommand(com.openxc.BinaryMessages.ModemConfigurationCommand value) {
3028         if (modemConfigurationCommandBuilder_ == null) {
3029           if (((bitField0_ & 0x00000040) == 0x00000040) &&
3030               modemConfigurationCommand_ != com.openxc.BinaryMessages.ModemConfigurationCommand.getDefaultInstance()) {
3031             modemConfigurationCommand_ =
3032               com.openxc.BinaryMessages.ModemConfigurationCommand.newBuilder(modemConfigurationCommand_).mergeFrom(value).buildPartial();
3033           } else {
3034             modemConfigurationCommand_ = value;
3035           }
3036           onChanged();
3037         } else {
3038           modemConfigurationCommandBuilder_.mergeFrom(value);
3039         }
3040         bitField0_ |= 0x00000040;
3041         return this;
3042       }
3043       public Builder clearModemConfigurationCommand() {
3044         if (modemConfigurationCommandBuilder_ == null) {
3045           modemConfigurationCommand_ = com.openxc.BinaryMessages.ModemConfigurationCommand.getDefaultInstance();
3046           onChanged();
3047         } else {
3048           modemConfigurationCommandBuilder_.clear();
3049         }
3050         bitField0_ = (bitField0_ & ~0x00000040);
3051         return this;
3052       }
3053       public com.openxc.BinaryMessages.ModemConfigurationCommand.Builder getModemConfigurationCommandBuilder() {
3054         bitField0_ |= 0x00000040;
3055         onChanged();
3056         return getModemConfigurationCommandFieldBuilder().getBuilder();
3057       }
3058       public com.openxc.BinaryMessages.ModemConfigurationCommandOrBuilder getModemConfigurationCommandOrBuilder() {
3059         if (modemConfigurationCommandBuilder_ != null) {
3060           return modemConfigurationCommandBuilder_.getMessageOrBuilder();
3061         } else {
3062           return modemConfigurationCommand_;
3063         }
3064       }
3065       private com.google.protobuf.SingleFieldBuilder<
3066           com.openxc.BinaryMessages.ModemConfigurationCommand, com.openxc.BinaryMessages.ModemConfigurationCommand.Builder, com.openxc.BinaryMessages.ModemConfigurationCommandOrBuilder>
3067           getModemConfigurationCommandFieldBuilder() {
3068         if (modemConfigurationCommandBuilder_ == null) {
3069           modemConfigurationCommandBuilder_ = new com.google.protobuf.SingleFieldBuilder<
3070               com.openxc.BinaryMessages.ModemConfigurationCommand, com.openxc.BinaryMessages.ModemConfigurationCommand.Builder, com.openxc.BinaryMessages.ModemConfigurationCommandOrBuilder>(
3071                   modemConfigurationCommand_,
3072                   getParentForChildren(),
3073                   isClean());
3074           modemConfigurationCommand_ = null;
3075         }
3076         return modemConfigurationCommandBuilder_;
3077       }
3078
3079       // @@protoc_insertion_point(builder_scope:openxc.ControlCommand)
3080     }
3081
3082     static {
3083       defaultInstance = new ControlCommand(true);
3084       defaultInstance.initFields();
3085     }
3086
3087     // @@protoc_insertion_point(class_scope:openxc.ControlCommand)
3088   }
3089
3090   public interface DiagnosticControlCommandOrBuilder
3091       extends com.google.protobuf.MessageOrBuilder {
3092
3093     // optional .openxc.DiagnosticRequest request = 1;
3094     boolean hasRequest();
3095     com.openxc.BinaryMessages.DiagnosticRequest getRequest();
3096     com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getRequestOrBuilder();
3097
3098     // optional .openxc.DiagnosticControlCommand.Action action = 2;
3099     boolean hasAction();
3100     com.openxc.BinaryMessages.DiagnosticControlCommand.Action getAction();
3101   }
3102   public static final class DiagnosticControlCommand extends
3103       com.google.protobuf.GeneratedMessage
3104       implements DiagnosticControlCommandOrBuilder {
3105     // Use DiagnosticControlCommand.newBuilder() to construct.
3106     private DiagnosticControlCommand(Builder builder) {
3107       super(builder);
3108     }
3109     private DiagnosticControlCommand(boolean noInit) {}
3110
3111     private static final DiagnosticControlCommand defaultInstance;
3112     public static DiagnosticControlCommand getDefaultInstance() {
3113       return defaultInstance;
3114     }
3115
3116     public DiagnosticControlCommand getDefaultInstanceForType() {
3117       return defaultInstance;
3118     }
3119
3120     public static final com.google.protobuf.Descriptors.Descriptor
3121         getDescriptor() {
3122       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticControlCommand_descriptor;
3123     }
3124
3125     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3126         internalGetFieldAccessorTable() {
3127       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticControlCommand_fieldAccessorTable;
3128     }
3129
3130     public enum Action
3131         implements com.google.protobuf.ProtocolMessageEnum {
3132       ADD(0, 1),
3133       CANCEL(1, 2),
3134       ;
3135
3136       public static final int ADD_VALUE = 1;
3137       public static final int CANCEL_VALUE = 2;
3138
3139
3140       public final int getNumber() { return value; }
3141
3142       public static Action valueOf(int value) {
3143         switch (value) {
3144           case 1: return ADD;
3145           case 2: return CANCEL;
3146           default: return null;
3147         }
3148       }
3149
3150       public static com.google.protobuf.Internal.EnumLiteMap<Action>
3151           internalGetValueMap() {
3152         return internalValueMap;
3153       }
3154       private static com.google.protobuf.Internal.EnumLiteMap<Action>
3155           internalValueMap =
3156             new com.google.protobuf.Internal.EnumLiteMap<Action>() {
3157               public Action findValueByNumber(int number) {
3158                 return Action.valueOf(number);
3159               }
3160             };
3161
3162       public final com.google.protobuf.Descriptors.EnumValueDescriptor
3163           getValueDescriptor() {
3164         return getDescriptor().getValues().get(index);
3165       }
3166       public final com.google.protobuf.Descriptors.EnumDescriptor
3167           getDescriptorForType() {
3168         return getDescriptor();
3169       }
3170       public static final com.google.protobuf.Descriptors.EnumDescriptor
3171           getDescriptor() {
3172         return com.openxc.BinaryMessages.DiagnosticControlCommand.getDescriptor().getEnumTypes().get(0);
3173       }
3174
3175       private static final Action[] VALUES = {
3176         ADD, CANCEL,
3177       };
3178
3179       public static Action valueOf(
3180           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
3181         if (desc.getType() != getDescriptor()) {
3182           throw new java.lang.IllegalArgumentException(
3183             "EnumValueDescriptor is not for this type.");
3184         }
3185         return VALUES[desc.getIndex()];
3186       }
3187
3188       private final int index;
3189       private final int value;
3190
3191       private Action(int index, int value) {
3192         this.index = index;
3193         this.value = value;
3194       }
3195
3196       // @@protoc_insertion_point(enum_scope:openxc.DiagnosticControlCommand.Action)
3197     }
3198
3199     private int bitField0_;
3200     // optional .openxc.DiagnosticRequest request = 1;
3201     public static final int REQUEST_FIELD_NUMBER = 1;
3202     private com.openxc.BinaryMessages.DiagnosticRequest request_;
3203     public boolean hasRequest() {
3204       return ((bitField0_ & 0x00000001) == 0x00000001);
3205     }
3206     public com.openxc.BinaryMessages.DiagnosticRequest getRequest() {
3207       return request_;
3208     }
3209     public com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getRequestOrBuilder() {
3210       return request_;
3211     }
3212
3213     // optional .openxc.DiagnosticControlCommand.Action action = 2;
3214     public static final int ACTION_FIELD_NUMBER = 2;
3215     private com.openxc.BinaryMessages.DiagnosticControlCommand.Action action_;
3216     public boolean hasAction() {
3217       return ((bitField0_ & 0x00000002) == 0x00000002);
3218     }
3219     public com.openxc.BinaryMessages.DiagnosticControlCommand.Action getAction() {
3220       return action_;
3221     }
3222
3223     private void initFields() {
3224       request_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
3225       action_ = com.openxc.BinaryMessages.DiagnosticControlCommand.Action.ADD;
3226     }
3227     private byte memoizedIsInitialized = -1;
3228     public final boolean isInitialized() {
3229       byte isInitialized = memoizedIsInitialized;
3230       if (isInitialized != -1) return isInitialized == 1;
3231
3232       memoizedIsInitialized = 1;
3233       return true;
3234     }
3235
3236     public void writeTo(com.google.protobuf.CodedOutputStream output)
3237                         throws java.io.IOException {
3238       getSerializedSize();
3239       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3240         output.writeMessage(1, request_);
3241       }
3242       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3243         output.writeEnum(2, action_.getNumber());
3244       }
3245       getUnknownFields().writeTo(output);
3246     }
3247
3248     private int memoizedSerializedSize = -1;
3249     public int getSerializedSize() {
3250       int size = memoizedSerializedSize;
3251       if (size != -1) return size;
3252
3253       size = 0;
3254       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3255         size += com.google.protobuf.CodedOutputStream
3256           .computeMessageSize(1, request_);
3257       }
3258       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3259         size += com.google.protobuf.CodedOutputStream
3260           .computeEnumSize(2, action_.getNumber());
3261       }
3262       size += getUnknownFields().getSerializedSize();
3263       memoizedSerializedSize = size;
3264       return size;
3265     }
3266
3267     private static final long serialVersionUID = 0L;
3268     @java.lang.Override
3269     protected java.lang.Object writeReplace()
3270         throws java.io.ObjectStreamException {
3271       return super.writeReplace();
3272     }
3273
3274     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
3275         com.google.protobuf.ByteString data)
3276         throws com.google.protobuf.InvalidProtocolBufferException {
3277       return newBuilder().mergeFrom(data).buildParsed();
3278     }
3279     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
3280         com.google.protobuf.ByteString data,
3281         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3282         throws com.google.protobuf.InvalidProtocolBufferException {
3283       return newBuilder().mergeFrom(data, extensionRegistry)
3284                .buildParsed();
3285     }
3286     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(byte[] data)
3287         throws com.google.protobuf.InvalidProtocolBufferException {
3288       return newBuilder().mergeFrom(data).buildParsed();
3289     }
3290     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
3291         byte[] data,
3292         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3293         throws com.google.protobuf.InvalidProtocolBufferException {
3294       return newBuilder().mergeFrom(data, extensionRegistry)
3295                .buildParsed();
3296     }
3297     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(java.io.InputStream input)
3298         throws java.io.IOException {
3299       return newBuilder().mergeFrom(input).buildParsed();
3300     }
3301     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
3302         java.io.InputStream input,
3303         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3304         throws java.io.IOException {
3305       return newBuilder().mergeFrom(input, extensionRegistry)
3306                .buildParsed();
3307     }
3308     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseDelimitedFrom(java.io.InputStream input)
3309         throws java.io.IOException {
3310       Builder builder = newBuilder();
3311       if (builder.mergeDelimitedFrom(input)) {
3312         return builder.buildParsed();
3313       } else {
3314         return null;
3315       }
3316     }
3317     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseDelimitedFrom(
3318         java.io.InputStream input,
3319         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3320         throws java.io.IOException {
3321       Builder builder = newBuilder();
3322       if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
3323         return builder.buildParsed();
3324       } else {
3325         return null;
3326       }
3327     }
3328     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
3329         com.google.protobuf.CodedInputStream input)
3330         throws java.io.IOException {
3331       return newBuilder().mergeFrom(input).buildParsed();
3332     }
3333     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
3334         com.google.protobuf.CodedInputStream input,
3335         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3336         throws java.io.IOException {
3337       return newBuilder().mergeFrom(input, extensionRegistry)
3338                .buildParsed();
3339     }
3340
3341     public static Builder newBuilder() { return Builder.create(); }
3342     public Builder newBuilderForType() { return newBuilder(); }
3343     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticControlCommand prototype) {
3344       return newBuilder().mergeFrom(prototype);
3345     }
3346     public Builder toBuilder() { return newBuilder(this); }
3347
3348     @java.lang.Override
3349     protected Builder newBuilderForType(
3350         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3351       Builder builder = new Builder(parent);
3352       return builder;
3353     }
3354     public static final class Builder extends
3355         com.google.protobuf.GeneratedMessage.Builder<Builder>
3356        implements com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder {
3357       public static final com.google.protobuf.Descriptors.Descriptor
3358           getDescriptor() {
3359         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticControlCommand_descriptor;
3360       }
3361
3362       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3363           internalGetFieldAccessorTable() {
3364         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticControlCommand_fieldAccessorTable;
3365       }
3366
3367       // Construct using com.openxc.BinaryMessages.DiagnosticControlCommand.newBuilder()
3368       private Builder() {
3369         maybeForceBuilderInitialization();
3370       }
3371
3372       private Builder(BuilderParent parent) {
3373         super(parent);
3374         maybeForceBuilderInitialization();
3375       }
3376       private void maybeForceBuilderInitialization() {
3377         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
3378           getRequestFieldBuilder();
3379         }
3380       }
3381       private static Builder create() {
3382         return new Builder();
3383       }
3384
3385       public Builder clear() {
3386         super.clear();
3387         if (requestBuilder_ == null) {
3388           request_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
3389         } else {
3390           requestBuilder_.clear();
3391         }
3392         bitField0_ = (bitField0_ & ~0x00000001);
3393         action_ = com.openxc.BinaryMessages.DiagnosticControlCommand.Action.ADD;
3394         bitField0_ = (bitField0_ & ~0x00000002);
3395         return this;
3396       }
3397
3398       public Builder clone() {
3399         return create().mergeFrom(buildPartial());
3400       }
3401
3402       public com.google.protobuf.Descriptors.Descriptor
3403           getDescriptorForType() {
3404         return com.openxc.BinaryMessages.DiagnosticControlCommand.getDescriptor();
3405       }
3406
3407       public com.openxc.BinaryMessages.DiagnosticControlCommand getDefaultInstanceForType() {
3408         return com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance();
3409       }
3410
3411       public com.openxc.BinaryMessages.DiagnosticControlCommand build() {
3412         com.openxc.BinaryMessages.DiagnosticControlCommand result = buildPartial();
3413         if (!result.isInitialized()) {
3414           throw newUninitializedMessageException(result);
3415         }
3416         return result;
3417       }
3418
3419       private com.openxc.BinaryMessages.DiagnosticControlCommand buildParsed()
3420           throws com.google.protobuf.InvalidProtocolBufferException {
3421         com.openxc.BinaryMessages.DiagnosticControlCommand result = buildPartial();
3422         if (!result.isInitialized()) {
3423           throw newUninitializedMessageException(
3424             result).asInvalidProtocolBufferException();
3425         }
3426         return result;
3427       }
3428
3429       public com.openxc.BinaryMessages.DiagnosticControlCommand buildPartial() {
3430         com.openxc.BinaryMessages.DiagnosticControlCommand result = new com.openxc.BinaryMessages.DiagnosticControlCommand(this);
3431         int from_bitField0_ = bitField0_;
3432         int to_bitField0_ = 0;
3433         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
3434           to_bitField0_ |= 0x00000001;
3435         }
3436         if (requestBuilder_ == null) {
3437           result.request_ = request_;
3438         } else {
3439           result.request_ = requestBuilder_.build();
3440         }
3441         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
3442           to_bitField0_ |= 0x00000002;
3443         }
3444         result.action_ = action_;
3445         result.bitField0_ = to_bitField0_;
3446         onBuilt();
3447         return result;
3448       }
3449
3450       public Builder mergeFrom(com.google.protobuf.Message other) {
3451         if (other instanceof com.openxc.BinaryMessages.DiagnosticControlCommand) {
3452           return mergeFrom((com.openxc.BinaryMessages.DiagnosticControlCommand)other);
3453         } else {
3454           super.mergeFrom(other);
3455           return this;
3456         }
3457       }
3458
3459       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticControlCommand other) {
3460         if (other == com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance()) return this;
3461         if (other.hasRequest()) {
3462           mergeRequest(other.getRequest());
3463         }
3464         if (other.hasAction()) {
3465           setAction(other.getAction());
3466         }
3467         this.mergeUnknownFields(other.getUnknownFields());
3468         return this;
3469       }
3470
3471       public final boolean isInitialized() {
3472         return true;
3473       }
3474
3475       public Builder mergeFrom(
3476           com.google.protobuf.CodedInputStream input,
3477           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3478           throws java.io.IOException {
3479         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
3480           com.google.protobuf.UnknownFieldSet.newBuilder(
3481             this.getUnknownFields());
3482         while (true) {
3483           int tag = input.readTag();
3484           switch (tag) {
3485             case 0:
3486               this.setUnknownFields(unknownFields.build());
3487               onChanged();
3488               return this;
3489             default: {
3490               if (!parseUnknownField(input, unknownFields,
3491                                      extensionRegistry, tag)) {
3492                 this.setUnknownFields(unknownFields.build());
3493                 onChanged();
3494                 return this;
3495               }
3496               break;
3497             }
3498             case 10: {
3499               com.openxc.BinaryMessages.DiagnosticRequest.Builder subBuilder = com.openxc.BinaryMessages.DiagnosticRequest.newBuilder();
3500               if (hasRequest()) {
3501                 subBuilder.mergeFrom(getRequest());
3502               }
3503               input.readMessage(subBuilder, extensionRegistry);
3504               setRequest(subBuilder.buildPartial());
3505               break;
3506             }
3507             case 16: {
3508               int rawValue = input.readEnum();
3509               com.openxc.BinaryMessages.DiagnosticControlCommand.Action value = com.openxc.BinaryMessages.DiagnosticControlCommand.Action.valueOf(rawValue);
3510               if (value == null) {
3511                 unknownFields.mergeVarintField(2, rawValue);
3512               } else {
3513                 bitField0_ |= 0x00000002;
3514                 action_ = value;
3515               }
3516               break;
3517             }
3518           }
3519         }
3520       }
3521
3522       private int bitField0_;
3523
3524       // optional .openxc.DiagnosticRequest request = 1;
3525       private com.openxc.BinaryMessages.DiagnosticRequest request_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
3526       private com.google.protobuf.SingleFieldBuilder<
3527           com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder> requestBuilder_;
3528       public boolean hasRequest() {
3529         return ((bitField0_ & 0x00000001) == 0x00000001);
3530       }
3531       public com.openxc.BinaryMessages.DiagnosticRequest getRequest() {
3532         if (requestBuilder_ == null) {
3533           return request_;
3534         } else {
3535           return requestBuilder_.getMessage();
3536         }
3537       }
3538       public Builder setRequest(com.openxc.BinaryMessages.DiagnosticRequest value) {
3539         if (requestBuilder_ == null) {
3540           if (value == null) {
3541             throw new NullPointerException();
3542           }
3543           request_ = value;
3544           onChanged();
3545         } else {
3546           requestBuilder_.setMessage(value);
3547         }
3548         bitField0_ |= 0x00000001;
3549         return this;
3550       }
3551       public Builder setRequest(
3552           com.openxc.BinaryMessages.DiagnosticRequest.Builder builderForValue) {
3553         if (requestBuilder_ == null) {
3554           request_ = builderForValue.build();
3555           onChanged();
3556         } else {
3557           requestBuilder_.setMessage(builderForValue.build());
3558         }
3559         bitField0_ |= 0x00000001;
3560         return this;
3561       }
3562       public Builder mergeRequest(com.openxc.BinaryMessages.DiagnosticRequest value) {
3563         if (requestBuilder_ == null) {
3564           if (((bitField0_ & 0x00000001) == 0x00000001) &&
3565               request_ != com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance()) {
3566             request_ =
3567               com.openxc.BinaryMessages.DiagnosticRequest.newBuilder(request_).mergeFrom(value).buildPartial();
3568           } else {
3569             request_ = value;
3570           }
3571           onChanged();
3572         } else {
3573           requestBuilder_.mergeFrom(value);
3574         }
3575         bitField0_ |= 0x00000001;
3576         return this;
3577       }
3578       public Builder clearRequest() {
3579         if (requestBuilder_ == null) {
3580           request_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
3581           onChanged();
3582         } else {
3583           requestBuilder_.clear();
3584         }
3585         bitField0_ = (bitField0_ & ~0x00000001);
3586         return this;
3587       }
3588       public com.openxc.BinaryMessages.DiagnosticRequest.Builder getRequestBuilder() {
3589         bitField0_ |= 0x00000001;
3590         onChanged();
3591         return getRequestFieldBuilder().getBuilder();
3592       }
3593       public com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getRequestOrBuilder() {
3594         if (requestBuilder_ != null) {
3595           return requestBuilder_.getMessageOrBuilder();
3596         } else {
3597           return request_;
3598         }
3599       }
3600       private com.google.protobuf.SingleFieldBuilder<
3601           com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder>
3602           getRequestFieldBuilder() {
3603         if (requestBuilder_ == null) {
3604           requestBuilder_ = new com.google.protobuf.SingleFieldBuilder<
3605               com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder>(
3606                   request_,
3607                   getParentForChildren(),
3608                   isClean());
3609           request_ = null;
3610         }
3611         return requestBuilder_;
3612       }
3613
3614       // optional .openxc.DiagnosticControlCommand.Action action = 2;
3615       private com.openxc.BinaryMessages.DiagnosticControlCommand.Action action_ = com.openxc.BinaryMessages.DiagnosticControlCommand.Action.ADD;
3616       public boolean hasAction() {
3617         return ((bitField0_ & 0x00000002) == 0x00000002);
3618       }
3619       public com.openxc.BinaryMessages.DiagnosticControlCommand.Action getAction() {
3620         return action_;
3621       }
3622       public Builder setAction(com.openxc.BinaryMessages.DiagnosticControlCommand.Action value) {
3623         if (value == null) {
3624           throw new NullPointerException();
3625         }
3626         bitField0_ |= 0x00000002;
3627         action_ = value;
3628         onChanged();
3629         return this;
3630       }
3631       public Builder clearAction() {
3632         bitField0_ = (bitField0_ & ~0x00000002);
3633         action_ = com.openxc.BinaryMessages.DiagnosticControlCommand.Action.ADD;
3634         onChanged();
3635         return this;
3636       }
3637
3638       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticControlCommand)
3639     }
3640
3641     static {
3642       defaultInstance = new DiagnosticControlCommand(true);
3643       defaultInstance.initFields();
3644     }
3645
3646     // @@protoc_insertion_point(class_scope:openxc.DiagnosticControlCommand)
3647   }
3648
3649   public interface PassthroughModeControlCommandOrBuilder
3650       extends com.google.protobuf.MessageOrBuilder {
3651
3652     // optional int32 bus = 1;
3653     boolean hasBus();
3654     int getBus();
3655
3656     // optional bool enabled = 2;
3657     boolean hasEnabled();
3658     boolean getEnabled();
3659   }
3660   public static final class PassthroughModeControlCommand extends
3661       com.google.protobuf.GeneratedMessage
3662       implements PassthroughModeControlCommandOrBuilder {
3663     // Use PassthroughModeControlCommand.newBuilder() to construct.
3664     private PassthroughModeControlCommand(Builder builder) {
3665       super(builder);
3666     }
3667     private PassthroughModeControlCommand(boolean noInit) {}
3668
3669     private static final PassthroughModeControlCommand defaultInstance;
3670     public static PassthroughModeControlCommand getDefaultInstance() {
3671       return defaultInstance;
3672     }
3673
3674     public PassthroughModeControlCommand getDefaultInstanceForType() {
3675       return defaultInstance;
3676     }
3677
3678     public static final com.google.protobuf.Descriptors.Descriptor
3679         getDescriptor() {
3680       return com.openxc.BinaryMessages.internal_static_openxc_PassthroughModeControlCommand_descriptor;
3681     }
3682
3683     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3684         internalGetFieldAccessorTable() {
3685       return com.openxc.BinaryMessages.internal_static_openxc_PassthroughModeControlCommand_fieldAccessorTable;
3686     }
3687
3688     private int bitField0_;
3689     // optional int32 bus = 1;
3690     public static final int BUS_FIELD_NUMBER = 1;
3691     private int bus_;
3692     public boolean hasBus() {
3693       return ((bitField0_ & 0x00000001) == 0x00000001);
3694     }
3695     public int getBus() {
3696       return bus_;
3697     }
3698
3699     // optional bool enabled = 2;
3700     public static final int ENABLED_FIELD_NUMBER = 2;
3701     private boolean enabled_;
3702     public boolean hasEnabled() {
3703       return ((bitField0_ & 0x00000002) == 0x00000002);
3704     }
3705     public boolean getEnabled() {
3706       return enabled_;
3707     }
3708
3709     private void initFields() {
3710       bus_ = 0;
3711       enabled_ = false;
3712     }
3713     private byte memoizedIsInitialized = -1;
3714     public final boolean isInitialized() {
3715       byte isInitialized = memoizedIsInitialized;
3716       if (isInitialized != -1) return isInitialized == 1;
3717
3718       memoizedIsInitialized = 1;
3719       return true;
3720     }
3721
3722     public void writeTo(com.google.protobuf.CodedOutputStream output)
3723                         throws java.io.IOException {
3724       getSerializedSize();
3725       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3726         output.writeInt32(1, bus_);
3727       }
3728       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3729         output.writeBool(2, enabled_);
3730       }
3731       getUnknownFields().writeTo(output);
3732     }
3733
3734     private int memoizedSerializedSize = -1;
3735     public int getSerializedSize() {
3736       int size = memoizedSerializedSize;
3737       if (size != -1) return size;
3738
3739       size = 0;
3740       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3741         size += com.google.protobuf.CodedOutputStream
3742           .computeInt32Size(1, bus_);
3743       }
3744       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3745         size += com.google.protobuf.CodedOutputStream
3746           .computeBoolSize(2, enabled_);
3747       }
3748       size += getUnknownFields().getSerializedSize();
3749       memoizedSerializedSize = size;
3750       return size;
3751     }
3752
3753     private static final long serialVersionUID = 0L;
3754     @java.lang.Override
3755     protected java.lang.Object writeReplace()
3756         throws java.io.ObjectStreamException {
3757       return super.writeReplace();
3758     }
3759
3760     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
3761         com.google.protobuf.ByteString data)
3762         throws com.google.protobuf.InvalidProtocolBufferException {
3763       return newBuilder().mergeFrom(data).buildParsed();
3764     }
3765     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
3766         com.google.protobuf.ByteString data,
3767         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3768         throws com.google.protobuf.InvalidProtocolBufferException {
3769       return newBuilder().mergeFrom(data, extensionRegistry)
3770                .buildParsed();
3771     }
3772     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(byte[] data)
3773         throws com.google.protobuf.InvalidProtocolBufferException {
3774       return newBuilder().mergeFrom(data).buildParsed();
3775     }
3776     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
3777         byte[] data,
3778         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3779         throws com.google.protobuf.InvalidProtocolBufferException {
3780       return newBuilder().mergeFrom(data, extensionRegistry)
3781                .buildParsed();
3782     }
3783     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(java.io.InputStream input)
3784         throws java.io.IOException {
3785       return newBuilder().mergeFrom(input).buildParsed();
3786     }
3787     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
3788         java.io.InputStream input,
3789         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3790         throws java.io.IOException {
3791       return newBuilder().mergeFrom(input, extensionRegistry)
3792                .buildParsed();
3793     }
3794     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseDelimitedFrom(java.io.InputStream input)
3795         throws java.io.IOException {
3796       Builder builder = newBuilder();
3797       if (builder.mergeDelimitedFrom(input)) {
3798         return builder.buildParsed();
3799       } else {
3800         return null;
3801       }
3802     }
3803     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseDelimitedFrom(
3804         java.io.InputStream input,
3805         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3806         throws java.io.IOException {
3807       Builder builder = newBuilder();
3808       if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
3809         return builder.buildParsed();
3810       } else {
3811         return null;
3812       }
3813     }
3814     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
3815         com.google.protobuf.CodedInputStream input)
3816         throws java.io.IOException {
3817       return newBuilder().mergeFrom(input).buildParsed();
3818     }
3819     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
3820         com.google.protobuf.CodedInputStream input,
3821         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3822         throws java.io.IOException {
3823       return newBuilder().mergeFrom(input, extensionRegistry)
3824                .buildParsed();
3825     }
3826
3827     public static Builder newBuilder() { return Builder.create(); }
3828     public Builder newBuilderForType() { return newBuilder(); }
3829     public static Builder newBuilder(com.openxc.BinaryMessages.PassthroughModeControlCommand prototype) {
3830       return newBuilder().mergeFrom(prototype);
3831     }
3832     public Builder toBuilder() { return newBuilder(this); }
3833
3834     @java.lang.Override
3835     protected Builder newBuilderForType(
3836         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3837       Builder builder = new Builder(parent);
3838       return builder;
3839     }
3840     public static final class Builder extends
3841         com.google.protobuf.GeneratedMessage.Builder<Builder>
3842        implements com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder {
3843       public static final com.google.protobuf.Descriptors.Descriptor
3844           getDescriptor() {
3845         return com.openxc.BinaryMessages.internal_static_openxc_PassthroughModeControlCommand_descriptor;
3846       }
3847
3848       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3849           internalGetFieldAccessorTable() {
3850         return com.openxc.BinaryMessages.internal_static_openxc_PassthroughModeControlCommand_fieldAccessorTable;
3851       }
3852
3853       // Construct using com.openxc.BinaryMessages.PassthroughModeControlCommand.newBuilder()
3854       private Builder() {
3855         maybeForceBuilderInitialization();
3856       }
3857
3858       private Builder(BuilderParent parent) {
3859         super(parent);
3860         maybeForceBuilderInitialization();
3861       }
3862       private void maybeForceBuilderInitialization() {
3863         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
3864         }
3865       }
3866       private static Builder create() {
3867         return new Builder();
3868       }
3869
3870       public Builder clear() {
3871         super.clear();
3872         bus_ = 0;
3873         bitField0_ = (bitField0_ & ~0x00000001);
3874         enabled_ = false;
3875         bitField0_ = (bitField0_ & ~0x00000002);
3876         return this;
3877       }
3878
3879       public Builder clone() {
3880         return create().mergeFrom(buildPartial());
3881       }
3882
3883       public com.google.protobuf.Descriptors.Descriptor
3884           getDescriptorForType() {
3885         return com.openxc.BinaryMessages.PassthroughModeControlCommand.getDescriptor();
3886       }
3887
3888       public com.openxc.BinaryMessages.PassthroughModeControlCommand getDefaultInstanceForType() {
3889         return com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance();
3890       }
3891
3892       public com.openxc.BinaryMessages.PassthroughModeControlCommand build() {
3893         com.openxc.BinaryMessages.PassthroughModeControlCommand result = buildPartial();
3894         if (!result.isInitialized()) {
3895           throw newUninitializedMessageException(result);
3896         }
3897         return result;
3898       }
3899
3900       private com.openxc.BinaryMessages.PassthroughModeControlCommand buildParsed()
3901           throws com.google.protobuf.InvalidProtocolBufferException {
3902         com.openxc.BinaryMessages.PassthroughModeControlCommand result = buildPartial();
3903         if (!result.isInitialized()) {
3904           throw newUninitializedMessageException(
3905             result).asInvalidProtocolBufferException();
3906         }
3907         return result;
3908       }
3909
3910       public com.openxc.BinaryMessages.PassthroughModeControlCommand buildPartial() {
3911         com.openxc.BinaryMessages.PassthroughModeControlCommand result = new com.openxc.BinaryMessages.PassthroughModeControlCommand(this);
3912         int from_bitField0_ = bitField0_;
3913         int to_bitField0_ = 0;
3914         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
3915           to_bitField0_ |= 0x00000001;
3916         }
3917         result.bus_ = bus_;
3918         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
3919           to_bitField0_ |= 0x00000002;
3920         }
3921         result.enabled_ = enabled_;
3922         result.bitField0_ = to_bitField0_;
3923         onBuilt();
3924         return result;
3925       }
3926
3927       public Builder mergeFrom(com.google.protobuf.Message other) {
3928         if (other instanceof com.openxc.BinaryMessages.PassthroughModeControlCommand) {
3929           return mergeFrom((com.openxc.BinaryMessages.PassthroughModeControlCommand)other);
3930         } else {
3931           super.mergeFrom(other);
3932           return this;
3933         }
3934       }
3935
3936       public Builder mergeFrom(com.openxc.BinaryMessages.PassthroughModeControlCommand other) {
3937         if (other == com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance()) return this;
3938         if (other.hasBus()) {
3939           setBus(other.getBus());
3940         }
3941         if (other.hasEnabled()) {
3942           setEnabled(other.getEnabled());
3943         }
3944         this.mergeUnknownFields(other.getUnknownFields());
3945         return this;
3946       }
3947
3948       public final boolean isInitialized() {
3949         return true;
3950       }
3951
3952       public Builder mergeFrom(
3953           com.google.protobuf.CodedInputStream input,
3954           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3955           throws java.io.IOException {
3956         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
3957           com.google.protobuf.UnknownFieldSet.newBuilder(
3958             this.getUnknownFields());
3959         while (true) {
3960           int tag = input.readTag();
3961           switch (tag) {
3962             case 0:
3963               this.setUnknownFields(unknownFields.build());
3964               onChanged();
3965               return this;
3966             default: {
3967               if (!parseUnknownField(input, unknownFields,
3968                                      extensionRegistry, tag)) {
3969                 this.setUnknownFields(unknownFields.build());
3970                 onChanged();
3971                 return this;
3972               }
3973               break;
3974             }
3975             case 8: {
3976               bitField0_ |= 0x00000001;
3977               bus_ = input.readInt32();
3978               break;
3979             }
3980             case 16: {
3981               bitField0_ |= 0x00000002;
3982               enabled_ = input.readBool();
3983               break;
3984             }
3985           }
3986         }
3987       }
3988
3989       private int bitField0_;
3990
3991       // optional int32 bus = 1;
3992       private int bus_ ;
3993       public boolean hasBus() {
3994         return ((bitField0_ & 0x00000001) == 0x00000001);
3995       }
3996       public int getBus() {
3997         return bus_;
3998       }
3999       public Builder setBus(int value) {
4000         bitField0_ |= 0x00000001;
4001         bus_ = value;
4002         onChanged();
4003         return this;
4004       }
4005       public Builder clearBus() {
4006         bitField0_ = (bitField0_ & ~0x00000001);
4007         bus_ = 0;
4008         onChanged();
4009         return this;
4010       }
4011
4012       // optional bool enabled = 2;
4013       private boolean enabled_ ;
4014       public boolean hasEnabled() {
4015         return ((bitField0_ & 0x00000002) == 0x00000002);
4016       }
4017       public boolean getEnabled() {
4018         return enabled_;
4019       }
4020       public Builder setEnabled(boolean value) {
4021         bitField0_ |= 0x00000002;
4022         enabled_ = value;
4023         onChanged();
4024         return this;
4025       }
4026       public Builder clearEnabled() {
4027         bitField0_ = (bitField0_ & ~0x00000002);
4028         enabled_ = false;
4029         onChanged();
4030         return this;
4031       }
4032
4033       // @@protoc_insertion_point(builder_scope:openxc.PassthroughModeControlCommand)
4034     }
4035
4036     static {
4037       defaultInstance = new PassthroughModeControlCommand(true);
4038       defaultInstance.initFields();
4039     }
4040
4041     // @@protoc_insertion_point(class_scope:openxc.PassthroughModeControlCommand)
4042   }
4043
4044   public interface AcceptanceFilterBypassCommandOrBuilder
4045       extends com.google.protobuf.MessageOrBuilder {
4046
4047     // optional int32 bus = 1;
4048     boolean hasBus();
4049     int getBus();
4050
4051     // optional bool bypass = 2;
4052     boolean hasBypass();
4053     boolean getBypass();
4054   }
4055   public static final class AcceptanceFilterBypassCommand extends
4056       com.google.protobuf.GeneratedMessage
4057       implements AcceptanceFilterBypassCommandOrBuilder {
4058     // Use AcceptanceFilterBypassCommand.newBuilder() to construct.
4059     private AcceptanceFilterBypassCommand(Builder builder) {
4060       super(builder);
4061     }
4062     private AcceptanceFilterBypassCommand(boolean noInit) {}
4063
4064     private static final AcceptanceFilterBypassCommand defaultInstance;
4065     public static AcceptanceFilterBypassCommand getDefaultInstance() {
4066       return defaultInstance;
4067     }
4068
4069     public AcceptanceFilterBypassCommand getDefaultInstanceForType() {
4070       return defaultInstance;
4071     }
4072
4073     public static final com.google.protobuf.Descriptors.Descriptor
4074         getDescriptor() {
4075       return com.openxc.BinaryMessages.internal_static_openxc_AcceptanceFilterBypassCommand_descriptor;
4076     }
4077
4078     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4079         internalGetFieldAccessorTable() {
4080       return com.openxc.BinaryMessages.internal_static_openxc_AcceptanceFilterBypassCommand_fieldAccessorTable;
4081     }
4082
4083     private int bitField0_;
4084     // optional int32 bus = 1;
4085     public static final int BUS_FIELD_NUMBER = 1;
4086     private int bus_;
4087     public boolean hasBus() {
4088       return ((bitField0_ & 0x00000001) == 0x00000001);
4089     }
4090     public int getBus() {
4091       return bus_;
4092     }
4093
4094     // optional bool bypass = 2;
4095     public static final int BYPASS_FIELD_NUMBER = 2;
4096     private boolean bypass_;
4097     public boolean hasBypass() {
4098       return ((bitField0_ & 0x00000002) == 0x00000002);
4099     }
4100     public boolean getBypass() {
4101       return bypass_;
4102     }
4103
4104     private void initFields() {
4105       bus_ = 0;
4106       bypass_ = false;
4107     }
4108     private byte memoizedIsInitialized = -1;
4109     public final boolean isInitialized() {
4110       byte isInitialized = memoizedIsInitialized;
4111       if (isInitialized != -1) return isInitialized == 1;
4112
4113       memoizedIsInitialized = 1;
4114       return true;
4115     }
4116
4117     public void writeTo(com.google.protobuf.CodedOutputStream output)
4118                         throws java.io.IOException {
4119       getSerializedSize();
4120       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4121         output.writeInt32(1, bus_);
4122       }
4123       if (((bitField0_ & 0x00000002) == 0x00000002)) {
4124         output.writeBool(2, bypass_);
4125       }
4126       getUnknownFields().writeTo(output);
4127     }
4128
4129     private int memoizedSerializedSize = -1;
4130     public int getSerializedSize() {
4131       int size = memoizedSerializedSize;
4132       if (size != -1) return size;
4133
4134       size = 0;
4135       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4136         size += com.google.protobuf.CodedOutputStream
4137           .computeInt32Size(1, bus_);
4138       }
4139       if (((bitField0_ & 0x00000002) == 0x00000002)) {
4140         size += com.google.protobuf.CodedOutputStream
4141           .computeBoolSize(2, bypass_);
4142       }
4143       size += getUnknownFields().getSerializedSize();
4144       memoizedSerializedSize = size;
4145       return size;
4146     }
4147
4148     private static final long serialVersionUID = 0L;
4149     @java.lang.Override
4150     protected java.lang.Object writeReplace()
4151         throws java.io.ObjectStreamException {
4152       return super.writeReplace();
4153     }
4154
4155     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseFrom(
4156         com.google.protobuf.ByteString data)
4157         throws com.google.protobuf.InvalidProtocolBufferException {
4158       return newBuilder().mergeFrom(data).buildParsed();
4159     }
4160     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseFrom(
4161         com.google.protobuf.ByteString data,
4162         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4163         throws com.google.protobuf.InvalidProtocolBufferException {
4164       return newBuilder().mergeFrom(data, extensionRegistry)
4165                .buildParsed();
4166     }
4167     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseFrom(byte[] data)
4168         throws com.google.protobuf.InvalidProtocolBufferException {
4169       return newBuilder().mergeFrom(data).buildParsed();
4170     }
4171     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseFrom(
4172         byte[] data,
4173         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4174         throws com.google.protobuf.InvalidProtocolBufferException {
4175       return newBuilder().mergeFrom(data, extensionRegistry)
4176                .buildParsed();
4177     }
4178     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseFrom(java.io.InputStream input)
4179         throws java.io.IOException {
4180       return newBuilder().mergeFrom(input).buildParsed();
4181     }
4182     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseFrom(
4183         java.io.InputStream input,
4184         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4185         throws java.io.IOException {
4186       return newBuilder().mergeFrom(input, extensionRegistry)
4187                .buildParsed();
4188     }
4189     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseDelimitedFrom(java.io.InputStream input)
4190         throws java.io.IOException {
4191       Builder builder = newBuilder();
4192       if (builder.mergeDelimitedFrom(input)) {
4193         return builder.buildParsed();
4194       } else {
4195         return null;
4196       }
4197     }
4198     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseDelimitedFrom(
4199         java.io.InputStream input,
4200         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4201         throws java.io.IOException {
4202       Builder builder = newBuilder();
4203       if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
4204         return builder.buildParsed();
4205       } else {
4206         return null;
4207       }
4208     }
4209     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseFrom(
4210         com.google.protobuf.CodedInputStream input)
4211         throws java.io.IOException {
4212       return newBuilder().mergeFrom(input).buildParsed();
4213     }
4214     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseFrom(
4215         com.google.protobuf.CodedInputStream input,
4216         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4217         throws java.io.IOException {
4218       return newBuilder().mergeFrom(input, extensionRegistry)
4219                .buildParsed();
4220     }
4221
4222     public static Builder newBuilder() { return Builder.create(); }
4223     public Builder newBuilderForType() { return newBuilder(); }
4224     public static Builder newBuilder(com.openxc.BinaryMessages.AcceptanceFilterBypassCommand prototype) {
4225       return newBuilder().mergeFrom(prototype);
4226     }
4227     public Builder toBuilder() { return newBuilder(this); }
4228
4229     @java.lang.Override
4230     protected Builder newBuilderForType(
4231         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4232       Builder builder = new Builder(parent);
4233       return builder;
4234     }
4235     public static final class Builder extends
4236         com.google.protobuf.GeneratedMessage.Builder<Builder>
4237        implements com.openxc.BinaryMessages.AcceptanceFilterBypassCommandOrBuilder {
4238       public static final com.google.protobuf.Descriptors.Descriptor
4239           getDescriptor() {
4240         return com.openxc.BinaryMessages.internal_static_openxc_AcceptanceFilterBypassCommand_descriptor;
4241       }
4242
4243       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4244           internalGetFieldAccessorTable() {
4245         return com.openxc.BinaryMessages.internal_static_openxc_AcceptanceFilterBypassCommand_fieldAccessorTable;
4246       }
4247
4248       // Construct using com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.newBuilder()
4249       private Builder() {
4250         maybeForceBuilderInitialization();
4251       }
4252
4253       private Builder(BuilderParent parent) {
4254         super(parent);
4255         maybeForceBuilderInitialization();
4256       }
4257       private void maybeForceBuilderInitialization() {
4258         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
4259         }
4260       }
4261       private static Builder create() {
4262         return new Builder();
4263       }
4264
4265       public Builder clear() {
4266         super.clear();
4267         bus_ = 0;
4268         bitField0_ = (bitField0_ & ~0x00000001);
4269         bypass_ = false;
4270         bitField0_ = (bitField0_ & ~0x00000002);
4271         return this;
4272       }
4273
4274       public Builder clone() {
4275         return create().mergeFrom(buildPartial());
4276       }
4277
4278       public com.google.protobuf.Descriptors.Descriptor
4279           getDescriptorForType() {
4280         return com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.getDescriptor();
4281       }
4282
4283       public com.openxc.BinaryMessages.AcceptanceFilterBypassCommand getDefaultInstanceForType() {
4284         return com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.getDefaultInstance();
4285       }
4286
4287       public com.openxc.BinaryMessages.AcceptanceFilterBypassCommand build() {
4288         com.openxc.BinaryMessages.AcceptanceFilterBypassCommand result = buildPartial();
4289         if (!result.isInitialized()) {
4290           throw newUninitializedMessageException(result);
4291         }
4292         return result;
4293       }
4294
4295       private com.openxc.BinaryMessages.AcceptanceFilterBypassCommand buildParsed()
4296           throws com.google.protobuf.InvalidProtocolBufferException {
4297         com.openxc.BinaryMessages.AcceptanceFilterBypassCommand result = buildPartial();
4298         if (!result.isInitialized()) {
4299           throw newUninitializedMessageException(
4300             result).asInvalidProtocolBufferException();
4301         }
4302         return result;
4303       }
4304
4305       public com.openxc.BinaryMessages.AcceptanceFilterBypassCommand buildPartial() {
4306         com.openxc.BinaryMessages.AcceptanceFilterBypassCommand result = new com.openxc.BinaryMessages.AcceptanceFilterBypassCommand(this);
4307         int from_bitField0_ = bitField0_;
4308         int to_bitField0_ = 0;
4309         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
4310           to_bitField0_ |= 0x00000001;
4311         }
4312         result.bus_ = bus_;
4313         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
4314           to_bitField0_ |= 0x00000002;
4315         }
4316         result.bypass_ = bypass_;
4317         result.bitField0_ = to_bitField0_;
4318         onBuilt();
4319         return result;
4320       }
4321
4322       public Builder mergeFrom(com.google.protobuf.Message other) {
4323         if (other instanceof com.openxc.BinaryMessages.AcceptanceFilterBypassCommand) {
4324           return mergeFrom((com.openxc.BinaryMessages.AcceptanceFilterBypassCommand)other);
4325         } else {
4326           super.mergeFrom(other);
4327           return this;
4328         }
4329       }
4330
4331       public Builder mergeFrom(com.openxc.BinaryMessages.AcceptanceFilterBypassCommand other) {
4332         if (other == com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.getDefaultInstance()) return this;
4333         if (other.hasBus()) {
4334           setBus(other.getBus());
4335         }
4336         if (other.hasBypass()) {
4337           setBypass(other.getBypass());
4338         }
4339         this.mergeUnknownFields(other.getUnknownFields());
4340         return this;
4341       }
4342
4343       public final boolean isInitialized() {
4344         return true;
4345       }
4346
4347       public Builder mergeFrom(
4348           com.google.protobuf.CodedInputStream input,
4349           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4350           throws java.io.IOException {
4351         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
4352           com.google.protobuf.UnknownFieldSet.newBuilder(
4353             this.getUnknownFields());
4354         while (true) {
4355           int tag = input.readTag();
4356           switch (tag) {
4357             case 0:
4358               this.setUnknownFields(unknownFields.build());
4359               onChanged();
4360               return this;
4361             default: {
4362               if (!parseUnknownField(input, unknownFields,
4363                                      extensionRegistry, tag)) {
4364                 this.setUnknownFields(unknownFields.build());
4365                 onChanged();
4366                 return this;
4367               }
4368               break;
4369             }
4370             case 8: {
4371               bitField0_ |= 0x00000001;
4372               bus_ = input.readInt32();
4373               break;
4374             }
4375             case 16: {
4376               bitField0_ |= 0x00000002;
4377               bypass_ = input.readBool();
4378               break;
4379             }
4380           }
4381         }
4382       }
4383
4384       private int bitField0_;
4385
4386       // optional int32 bus = 1;
4387       private int bus_ ;
4388       public boolean hasBus() {
4389         return ((bitField0_ & 0x00000001) == 0x00000001);
4390       }
4391       public int getBus() {
4392         return bus_;
4393       }
4394       public Builder setBus(int value) {
4395         bitField0_ |= 0x00000001;
4396         bus_ = value;
4397         onChanged();
4398         return this;
4399       }
4400       public Builder clearBus() {
4401         bitField0_ = (bitField0_ & ~0x00000001);
4402         bus_ = 0;
4403         onChanged();
4404         return this;
4405       }
4406
4407       // optional bool bypass = 2;
4408       private boolean bypass_ ;
4409       public boolean hasBypass() {
4410         return ((bitField0_ & 0x00000002) == 0x00000002);
4411       }
4412       public boolean getBypass() {
4413         return bypass_;
4414       }
4415       public Builder setBypass(boolean value) {
4416         bitField0_ |= 0x00000002;
4417         bypass_ = value;
4418         onChanged();
4419         return this;
4420       }
4421       public Builder clearBypass() {
4422         bitField0_ = (bitField0_ & ~0x00000002);
4423         bypass_ = false;
4424         onChanged();
4425         return this;
4426       }
4427
4428       // @@protoc_insertion_point(builder_scope:openxc.AcceptanceFilterBypassCommand)
4429     }
4430
4431     static {
4432       defaultInstance = new AcceptanceFilterBypassCommand(true);
4433       defaultInstance.initFields();
4434     }
4435
4436     // @@protoc_insertion_point(class_scope:openxc.AcceptanceFilterBypassCommand)
4437   }
4438
4439   public interface PayloadFormatCommandOrBuilder
4440       extends com.google.protobuf.MessageOrBuilder {
4441
4442     // optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;
4443     boolean hasFormat();
4444     com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat getFormat();
4445   }
4446   public static final class PayloadFormatCommand extends
4447       com.google.protobuf.GeneratedMessage
4448       implements PayloadFormatCommandOrBuilder {
4449     // Use PayloadFormatCommand.newBuilder() to construct.
4450     private PayloadFormatCommand(Builder builder) {
4451       super(builder);
4452     }
4453     private PayloadFormatCommand(boolean noInit) {}
4454
4455     private static final PayloadFormatCommand defaultInstance;
4456     public static PayloadFormatCommand getDefaultInstance() {
4457       return defaultInstance;
4458     }
4459
4460     public PayloadFormatCommand getDefaultInstanceForType() {
4461       return defaultInstance;
4462     }
4463
4464     public static final com.google.protobuf.Descriptors.Descriptor
4465         getDescriptor() {
4466       return com.openxc.BinaryMessages.internal_static_openxc_PayloadFormatCommand_descriptor;
4467     }
4468
4469     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4470         internalGetFieldAccessorTable() {
4471       return com.openxc.BinaryMessages.internal_static_openxc_PayloadFormatCommand_fieldAccessorTable;
4472     }
4473
4474     public enum PayloadFormat
4475         implements com.google.protobuf.ProtocolMessageEnum {
4476       JSON(0, 1),
4477       PROTOBUF(1, 2),
4478       MESSAGEPACK(2, 3),
4479       ;
4480
4481       public static final int JSON_VALUE = 1;
4482       public static final int PROTOBUF_VALUE = 2;
4483       public static final int MESSAGEPACK_VALUE = 3;
4484
4485
4486       public final int getNumber() { return value; }
4487
4488       public static PayloadFormat valueOf(int value) {
4489         switch (value) {
4490           case 1: return JSON;
4491           case 2: return PROTOBUF;
4492           case 3: return MESSAGEPACK;
4493           default: return null;
4494         }
4495       }
4496
4497       public static com.google.protobuf.Internal.EnumLiteMap<PayloadFormat>
4498           internalGetValueMap() {
4499         return internalValueMap;
4500       }
4501       private static com.google.protobuf.Internal.EnumLiteMap<PayloadFormat>
4502           internalValueMap =
4503             new com.google.protobuf.Internal.EnumLiteMap<PayloadFormat>() {
4504               public PayloadFormat findValueByNumber(int number) {
4505                 return PayloadFormat.valueOf(number);
4506               }
4507             };
4508
4509       public final com.google.protobuf.Descriptors.EnumValueDescriptor
4510           getValueDescriptor() {
4511         return getDescriptor().getValues().get(index);
4512       }
4513       public final com.google.protobuf.Descriptors.EnumDescriptor
4514           getDescriptorForType() {
4515         return getDescriptor();
4516       }
4517       public static final com.google.protobuf.Descriptors.EnumDescriptor
4518           getDescriptor() {
4519         return com.openxc.BinaryMessages.PayloadFormatCommand.getDescriptor().getEnumTypes().get(0);
4520       }
4521
4522       private static final PayloadFormat[] VALUES = {
4523         JSON, PROTOBUF, MESSAGEPACK,
4524       };
4525
4526       public static PayloadFormat valueOf(
4527           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
4528         if (desc.getType() != getDescriptor()) {
4529           throw new java.lang.IllegalArgumentException(
4530             "EnumValueDescriptor is not for this type.");
4531         }
4532         return VALUES[desc.getIndex()];
4533       }
4534
4535       private final int index;
4536       private final int value;
4537
4538       private PayloadFormat(int index, int value) {
4539         this.index = index;
4540         this.value = value;
4541       }
4542
4543       // @@protoc_insertion_point(enum_scope:openxc.PayloadFormatCommand.PayloadFormat)
4544     }
4545
4546     private int bitField0_;
4547     // optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;
4548     public static final int FORMAT_FIELD_NUMBER = 1;
4549     private com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat format_;
4550     public boolean hasFormat() {
4551       return ((bitField0_ & 0x00000001) == 0x00000001);
4552     }
4553     public com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat getFormat() {
4554       return format_;
4555     }
4556
4557     private void initFields() {
4558       format_ = com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat.JSON;
4559     }
4560     private byte memoizedIsInitialized = -1;
4561     public final boolean isInitialized() {
4562       byte isInitialized = memoizedIsInitialized;
4563       if (isInitialized != -1) return isInitialized == 1;
4564
4565       memoizedIsInitialized = 1;
4566       return true;
4567     }
4568
4569     public void writeTo(com.google.protobuf.CodedOutputStream output)
4570                         throws java.io.IOException {
4571       getSerializedSize();
4572       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4573         output.writeEnum(1, format_.getNumber());
4574       }
4575       getUnknownFields().writeTo(output);
4576     }
4577
4578     private int memoizedSerializedSize = -1;
4579     public int getSerializedSize() {
4580       int size = memoizedSerializedSize;
4581       if (size != -1) return size;
4582
4583       size = 0;
4584       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4585         size += com.google.protobuf.CodedOutputStream
4586           .computeEnumSize(1, format_.getNumber());
4587       }
4588       size += getUnknownFields().getSerializedSize();
4589       memoizedSerializedSize = size;
4590       return size;
4591     }
4592
4593     private static final long serialVersionUID = 0L;
4594     @java.lang.Override
4595     protected java.lang.Object writeReplace()
4596         throws java.io.ObjectStreamException {
4597       return super.writeReplace();
4598     }
4599
4600     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
4601         com.google.protobuf.ByteString data)
4602         throws com.google.protobuf.InvalidProtocolBufferException {
4603       return newBuilder().mergeFrom(data).buildParsed();
4604     }
4605     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
4606         com.google.protobuf.ByteString data,
4607         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4608         throws com.google.protobuf.InvalidProtocolBufferException {
4609       return newBuilder().mergeFrom(data, extensionRegistry)
4610                .buildParsed();
4611     }
4612     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(byte[] data)
4613         throws com.google.protobuf.InvalidProtocolBufferException {
4614       return newBuilder().mergeFrom(data).buildParsed();
4615     }
4616     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
4617         byte[] data,
4618         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4619         throws com.google.protobuf.InvalidProtocolBufferException {
4620       return newBuilder().mergeFrom(data, extensionRegistry)
4621                .buildParsed();
4622     }
4623     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(java.io.InputStream input)
4624         throws java.io.IOException {
4625       return newBuilder().mergeFrom(input).buildParsed();
4626     }
4627     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
4628         java.io.InputStream input,
4629         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4630         throws java.io.IOException {
4631       return newBuilder().mergeFrom(input, extensionRegistry)
4632                .buildParsed();
4633     }
4634     public static com.openxc.BinaryMessages.PayloadFormatCommand parseDelimitedFrom(java.io.InputStream input)
4635         throws java.io.IOException {
4636       Builder builder = newBuilder();
4637       if (builder.mergeDelimitedFrom(input)) {
4638         return builder.buildParsed();
4639       } else {
4640         return null;
4641       }
4642     }
4643     public static com.openxc.BinaryMessages.PayloadFormatCommand parseDelimitedFrom(
4644         java.io.InputStream input,
4645         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4646         throws java.io.IOException {
4647       Builder builder = newBuilder();
4648       if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
4649         return builder.buildParsed();
4650       } else {
4651         return null;
4652       }
4653     }
4654     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
4655         com.google.protobuf.CodedInputStream input)
4656         throws java.io.IOException {
4657       return newBuilder().mergeFrom(input).buildParsed();
4658     }
4659     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
4660         com.google.protobuf.CodedInputStream input,
4661         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4662         throws java.io.IOException {
4663       return newBuilder().mergeFrom(input, extensionRegistry)
4664                .buildParsed();
4665     }
4666
4667     public static Builder newBuilder() { return Builder.create(); }
4668     public Builder newBuilderForType() { return newBuilder(); }
4669     public static Builder newBuilder(com.openxc.BinaryMessages.PayloadFormatCommand prototype) {
4670       return newBuilder().mergeFrom(prototype);
4671     }
4672     public Builder toBuilder() { return newBuilder(this); }
4673
4674     @java.lang.Override
4675     protected Builder newBuilderForType(
4676         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4677       Builder builder = new Builder(parent);
4678       return builder;
4679     }
4680     public static final class Builder extends
4681         com.google.protobuf.GeneratedMessage.Builder<Builder>
4682        implements com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder {
4683       public static final com.google.protobuf.Descriptors.Descriptor
4684           getDescriptor() {
4685         return com.openxc.BinaryMessages.internal_static_openxc_PayloadFormatCommand_descriptor;
4686       }
4687
4688       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4689           internalGetFieldAccessorTable() {
4690         return com.openxc.BinaryMessages.internal_static_openxc_PayloadFormatCommand_fieldAccessorTable;
4691       }
4692
4693       // Construct using com.openxc.BinaryMessages.PayloadFormatCommand.newBuilder()
4694       private Builder() {
4695         maybeForceBuilderInitialization();
4696       }
4697
4698       private Builder(BuilderParent parent) {
4699         super(parent);
4700         maybeForceBuilderInitialization();
4701       }
4702       private void maybeForceBuilderInitialization() {
4703         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
4704         }
4705       }
4706       private static Builder create() {
4707         return new Builder();
4708       }
4709
4710       public Builder clear() {
4711         super.clear();
4712         format_ = com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat.JSON;
4713         bitField0_ = (bitField0_ & ~0x00000001);
4714         return this;
4715       }
4716
4717       public Builder clone() {
4718         return create().mergeFrom(buildPartial());
4719       }
4720
4721       public com.google.protobuf.Descriptors.Descriptor
4722           getDescriptorForType() {
4723         return com.openxc.BinaryMessages.PayloadFormatCommand.getDescriptor();
4724       }
4725
4726       public com.openxc.BinaryMessages.PayloadFormatCommand getDefaultInstanceForType() {
4727         return com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance();
4728       }
4729
4730       public com.openxc.BinaryMessages.PayloadFormatCommand build() {
4731         com.openxc.BinaryMessages.PayloadFormatCommand result = buildPartial();
4732         if (!result.isInitialized()) {
4733           throw newUninitializedMessageException(result);
4734         }
4735         return result;
4736       }
4737
4738       private com.openxc.BinaryMessages.PayloadFormatCommand buildParsed()
4739           throws com.google.protobuf.InvalidProtocolBufferException {
4740         com.openxc.BinaryMessages.PayloadFormatCommand result = buildPartial();
4741         if (!result.isInitialized()) {
4742           throw newUninitializedMessageException(
4743             result).asInvalidProtocolBufferException();
4744         }
4745         return result;
4746       }
4747
4748       public com.openxc.BinaryMessages.PayloadFormatCommand buildPartial() {
4749         com.openxc.BinaryMessages.PayloadFormatCommand result = new com.openxc.BinaryMessages.PayloadFormatCommand(this);
4750         int from_bitField0_ = bitField0_;
4751         int to_bitField0_ = 0;
4752         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
4753           to_bitField0_ |= 0x00000001;
4754         }
4755         result.format_ = format_;
4756         result.bitField0_ = to_bitField0_;
4757         onBuilt();
4758         return result;
4759       }
4760
4761       public Builder mergeFrom(com.google.protobuf.Message other) {
4762         if (other instanceof com.openxc.BinaryMessages.PayloadFormatCommand) {
4763           return mergeFrom((com.openxc.BinaryMessages.PayloadFormatCommand)other);
4764         } else {
4765           super.mergeFrom(other);
4766           return this;
4767         }
4768       }
4769
4770       public Builder mergeFrom(com.openxc.BinaryMessages.PayloadFormatCommand other) {
4771         if (other == com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance()) return this;
4772         if (other.hasFormat()) {
4773           setFormat(other.getFormat());
4774         }
4775         this.mergeUnknownFields(other.getUnknownFields());
4776         return this;
4777       }
4778
4779       public final boolean isInitialized() {
4780         return true;
4781       }
4782
4783       public Builder mergeFrom(
4784           com.google.protobuf.CodedInputStream input,
4785           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4786           throws java.io.IOException {
4787         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
4788           com.google.protobuf.UnknownFieldSet.newBuilder(
4789             this.getUnknownFields());
4790         while (true) {
4791           int tag = input.readTag();
4792           switch (tag) {
4793             case 0:
4794               this.setUnknownFields(unknownFields.build());
4795               onChanged();
4796               return this;
4797             default: {
4798               if (!parseUnknownField(input, unknownFields,
4799                                      extensionRegistry, tag)) {
4800                 this.setUnknownFields(unknownFields.build());
4801                 onChanged();
4802                 return this;
4803               }
4804               break;
4805             }
4806             case 8: {
4807               int rawValue = input.readEnum();
4808               com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat value = com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat.valueOf(rawValue);
4809               if (value == null) {
4810                 unknownFields.mergeVarintField(1, rawValue);
4811               } else {
4812                 bitField0_ |= 0x00000001;
4813                 format_ = value;
4814               }
4815               break;
4816             }
4817           }
4818         }
4819       }
4820
4821       private int bitField0_;
4822
4823       // optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;
4824       private com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat format_ = com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat.JSON;
4825       public boolean hasFormat() {
4826         return ((bitField0_ & 0x00000001) == 0x00000001);
4827       }
4828       public com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat getFormat() {
4829         return format_;
4830       }
4831       public Builder setFormat(com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat value) {
4832         if (value == null) {
4833           throw new NullPointerException();
4834         }
4835         bitField0_ |= 0x00000001;
4836         format_ = value;
4837         onChanged();
4838         return this;
4839       }
4840       public Builder clearFormat() {
4841         bitField0_ = (bitField0_ & ~0x00000001);
4842         format_ = com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat.JSON;
4843         onChanged();
4844         return this;
4845       }
4846
4847       // @@protoc_insertion_point(builder_scope:openxc.PayloadFormatCommand)
4848     }
4849
4850     static {
4851       defaultInstance = new PayloadFormatCommand(true);
4852       defaultInstance.initFields();
4853     }
4854
4855     // @@protoc_insertion_point(class_scope:openxc.PayloadFormatCommand)
4856   }
4857
4858   public interface PredefinedObd2RequestsCommandOrBuilder
4859       extends com.google.protobuf.MessageOrBuilder {
4860
4861     // optional bool enabled = 1;
4862     boolean hasEnabled();
4863     boolean getEnabled();
4864   }
4865   public static final class PredefinedObd2RequestsCommand extends
4866       com.google.protobuf.GeneratedMessage
4867       implements PredefinedObd2RequestsCommandOrBuilder {
4868     // Use PredefinedObd2RequestsCommand.newBuilder() to construct.
4869     private PredefinedObd2RequestsCommand(Builder builder) {
4870       super(builder);
4871     }
4872     private PredefinedObd2RequestsCommand(boolean noInit) {}
4873
4874     private static final PredefinedObd2RequestsCommand defaultInstance;
4875     public static PredefinedObd2RequestsCommand getDefaultInstance() {
4876       return defaultInstance;
4877     }
4878
4879     public PredefinedObd2RequestsCommand getDefaultInstanceForType() {
4880       return defaultInstance;
4881     }
4882
4883     public static final com.google.protobuf.Descriptors.Descriptor
4884         getDescriptor() {
4885       return com.openxc.BinaryMessages.internal_static_openxc_PredefinedObd2RequestsCommand_descriptor;
4886     }
4887
4888     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4889         internalGetFieldAccessorTable() {
4890       return com.openxc.BinaryMessages.internal_static_openxc_PredefinedObd2RequestsCommand_fieldAccessorTable;
4891     }
4892
4893     private int bitField0_;
4894     // optional bool enabled = 1;
4895     public static final int ENABLED_FIELD_NUMBER = 1;
4896     private boolean enabled_;
4897     public boolean hasEnabled() {
4898       return ((bitField0_ & 0x00000001) == 0x00000001);
4899     }
4900     public boolean getEnabled() {
4901       return enabled_;
4902     }
4903
4904     private void initFields() {
4905       enabled_ = false;
4906     }
4907     private byte memoizedIsInitialized = -1;
4908     public final boolean isInitialized() {
4909       byte isInitialized = memoizedIsInitialized;
4910       if (isInitialized != -1) return isInitialized == 1;
4911
4912       memoizedIsInitialized = 1;
4913       return true;
4914     }
4915
4916     public void writeTo(com.google.protobuf.CodedOutputStream output)
4917                         throws java.io.IOException {
4918       getSerializedSize();
4919       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4920         output.writeBool(1, enabled_);
4921       }
4922       getUnknownFields().writeTo(output);
4923     }
4924
4925     private int memoizedSerializedSize = -1;
4926     public int getSerializedSize() {
4927       int size = memoizedSerializedSize;
4928       if (size != -1) return size;
4929
4930       size = 0;
4931       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4932         size += com.google.protobuf.CodedOutputStream
4933           .computeBoolSize(1, enabled_);
4934       }
4935       size += getUnknownFields().getSerializedSize();
4936       memoizedSerializedSize = size;
4937       return size;
4938     }
4939
4940     private static final long serialVersionUID = 0L;
4941     @java.lang.Override
4942     protected java.lang.Object writeReplace()
4943         throws java.io.ObjectStreamException {
4944       return super.writeReplace();
4945     }
4946
4947     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseFrom(
4948         com.google.protobuf.ByteString data)
4949         throws com.google.protobuf.InvalidProtocolBufferException {
4950       return newBuilder().mergeFrom(data).buildParsed();
4951     }
4952     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseFrom(
4953         com.google.protobuf.ByteString data,
4954         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4955         throws com.google.protobuf.InvalidProtocolBufferException {
4956       return newBuilder().mergeFrom(data, extensionRegistry)
4957                .buildParsed();
4958     }
4959     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseFrom(byte[] data)
4960         throws com.google.protobuf.InvalidProtocolBufferException {
4961       return newBuilder().mergeFrom(data).buildParsed();
4962     }
4963     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseFrom(
4964         byte[] data,
4965         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4966         throws com.google.protobuf.InvalidProtocolBufferException {
4967       return newBuilder().mergeFrom(data, extensionRegistry)
4968                .buildParsed();
4969     }
4970     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseFrom(java.io.InputStream input)
4971         throws java.io.IOException {
4972       return newBuilder().mergeFrom(input).buildParsed();
4973     }
4974     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseFrom(
4975         java.io.InputStream input,
4976         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4977         throws java.io.IOException {
4978       return newBuilder().mergeFrom(input, extensionRegistry)
4979                .buildParsed();
4980     }
4981     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseDelimitedFrom(java.io.InputStream input)
4982         throws java.io.IOException {
4983       Builder builder = newBuilder();
4984       if (builder.mergeDelimitedFrom(input)) {
4985         return builder.buildParsed();
4986       } else {
4987         return null;
4988       }
4989     }
4990     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseDelimitedFrom(
4991         java.io.InputStream input,
4992         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4993         throws java.io.IOException {
4994       Builder builder = newBuilder();
4995       if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
4996         return builder.buildParsed();
4997       } else {
4998         return null;
4999       }
5000     }
5001     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseFrom(
5002         com.google.protobuf.CodedInputStream input)
5003         throws java.io.IOException {
5004       return newBuilder().mergeFrom(input).buildParsed();
5005     }
5006     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseFrom(
5007         com.google.protobuf.CodedInputStream input,
5008         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5009         throws java.io.IOException {
5010       return newBuilder().mergeFrom(input, extensionRegistry)
5011                .buildParsed();
5012     }
5013
5014     public static Builder newBuilder() { return Builder.create(); }
5015     public Builder newBuilderForType() { return newBuilder(); }
5016     public static Builder newBuilder(com.openxc.BinaryMessages.PredefinedObd2RequestsCommand prototype) {
5017       return newBuilder().mergeFrom(prototype);
5018     }
5019     public Builder toBuilder() { return newBuilder(this); }
5020
5021     @java.lang.Override
5022     protected Builder newBuilderForType(
5023         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5024       Builder builder = new Builder(parent);
5025       return builder;
5026     }
5027     public static final class Builder extends
5028         com.google.protobuf.GeneratedMessage.Builder<Builder>
5029        implements com.openxc.BinaryMessages.PredefinedObd2RequestsCommandOrBuilder {
5030       public static final com.google.protobuf.Descriptors.Descriptor
5031           getDescriptor() {
5032         return com.openxc.BinaryMessages.internal_static_openxc_PredefinedObd2RequestsCommand_descriptor;
5033       }
5034
5035       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5036           internalGetFieldAccessorTable() {
5037         return com.openxc.BinaryMessages.internal_static_openxc_PredefinedObd2RequestsCommand_fieldAccessorTable;
5038       }
5039
5040       // Construct using com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.newBuilder()
5041       private Builder() {
5042         maybeForceBuilderInitialization();
5043       }
5044
5045       private Builder(BuilderParent parent) {
5046         super(parent);
5047         maybeForceBuilderInitialization();
5048       }
5049       private void maybeForceBuilderInitialization() {
5050         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
5051         }
5052       }
5053       private static Builder create() {
5054         return new Builder();
5055       }
5056
5057       public Builder clear() {
5058         super.clear();
5059         enabled_ = false;
5060         bitField0_ = (bitField0_ & ~0x00000001);
5061         return this;
5062       }
5063
5064       public Builder clone() {
5065         return create().mergeFrom(buildPartial());
5066       }
5067
5068       public com.google.protobuf.Descriptors.Descriptor
5069           getDescriptorForType() {
5070         return com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.getDescriptor();
5071       }
5072
5073       public com.openxc.BinaryMessages.PredefinedObd2RequestsCommand getDefaultInstanceForType() {
5074         return com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.getDefaultInstance();
5075       }
5076
5077       public com.openxc.BinaryMessages.PredefinedObd2RequestsCommand build() {
5078         com.openxc.BinaryMessages.PredefinedObd2RequestsCommand result = buildPartial();
5079         if (!result.isInitialized()) {
5080           throw newUninitializedMessageException(result);
5081         }
5082         return result;
5083       }
5084
5085       private com.openxc.BinaryMessages.PredefinedObd2RequestsCommand buildParsed()
5086           throws com.google.protobuf.InvalidProtocolBufferException {
5087         com.openxc.BinaryMessages.PredefinedObd2RequestsCommand result = buildPartial();
5088         if (!result.isInitialized()) {
5089           throw newUninitializedMessageException(
5090             result).asInvalidProtocolBufferException();
5091         }
5092         return result;
5093       }
5094
5095       public com.openxc.BinaryMessages.PredefinedObd2RequestsCommand buildPartial() {
5096         com.openxc.BinaryMessages.PredefinedObd2RequestsCommand result = new com.openxc.BinaryMessages.PredefinedObd2RequestsCommand(this);
5097         int from_bitField0_ = bitField0_;
5098         int to_bitField0_ = 0;
5099         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
5100           to_bitField0_ |= 0x00000001;
5101         }
5102         result.enabled_ = enabled_;
5103         result.bitField0_ = to_bitField0_;
5104         onBuilt();
5105         return result;
5106       }
5107
5108       public Builder mergeFrom(com.google.protobuf.Message other) {
5109         if (other instanceof com.openxc.BinaryMessages.PredefinedObd2RequestsCommand) {
5110           return mergeFrom((com.openxc.BinaryMessages.PredefinedObd2RequestsCommand)other);
5111         } else {
5112           super.mergeFrom(other);
5113           return this;
5114         }
5115       }
5116
5117       public Builder mergeFrom(com.openxc.BinaryMessages.PredefinedObd2RequestsCommand other) {
5118         if (other == com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.getDefaultInstance()) return this;
5119         if (other.hasEnabled()) {
5120           setEnabled(other.getEnabled());
5121         }
5122         this.mergeUnknownFields(other.getUnknownFields());
5123         return this;
5124       }
5125
5126       public final boolean isInitialized() {
5127         return true;
5128       }
5129
5130       public Builder mergeFrom(
5131           com.google.protobuf.CodedInputStream input,
5132           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5133           throws java.io.IOException {
5134         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
5135           com.google.protobuf.UnknownFieldSet.newBuilder(
5136             this.getUnknownFields());
5137         while (true) {
5138           int tag = input.readTag();
5139           switch (tag) {
5140             case 0:
5141               this.setUnknownFields(unknownFields.build());
5142               onChanged();
5143               return this;
5144             default: {
5145               if (!parseUnknownField(input, unknownFields,
5146                                      extensionRegistry, tag)) {
5147                 this.setUnknownFields(unknownFields.build());
5148                 onChanged();
5149                 return this;
5150               }
5151               break;
5152             }
5153             case 8: {
5154               bitField0_ |= 0x00000001;
5155               enabled_ = input.readBool();
5156               break;
5157             }
5158           }
5159         }
5160       }
5161
5162       private int bitField0_;
5163
5164       // optional bool enabled = 1;
5165       private boolean enabled_ ;
5166       public boolean hasEnabled() {
5167         return ((bitField0_ & 0x00000001) == 0x00000001);
5168       }
5169       public boolean getEnabled() {
5170         return enabled_;
5171       }
5172       public Builder setEnabled(boolean value) {
5173         bitField0_ |= 0x00000001;
5174         enabled_ = value;
5175         onChanged();
5176         return this;
5177       }
5178       public Builder clearEnabled() {
5179         bitField0_ = (bitField0_ & ~0x00000001);
5180         enabled_ = false;
5181         onChanged();
5182         return this;
5183       }
5184
5185       // @@protoc_insertion_point(builder_scope:openxc.PredefinedObd2RequestsCommand)
5186     }
5187
5188     static {
5189       defaultInstance = new PredefinedObd2RequestsCommand(true);
5190       defaultInstance.initFields();
5191     }
5192
5193     // @@protoc_insertion_point(class_scope:openxc.PredefinedObd2RequestsCommand)
5194   }
5195
5196   public interface NetworkOperatorSettingsOrBuilder
5197       extends com.google.protobuf.MessageOrBuilder {
5198
5199     // optional bool allowDataRoaming = 1;
5200     boolean hasAllowDataRoaming();
5201     boolean getAllowDataRoaming();
5202
5203     // optional .openxc.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode = 2;
5204     boolean hasOperatorSelectMode();
5205     com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode getOperatorSelectMode();
5206
5207     // optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;
5208     boolean hasNetworkDescriptor();
5209     com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor getNetworkDescriptor();
5210     com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptorOrBuilder getNetworkDescriptorOrBuilder();
5211   }
5212   public static final class NetworkOperatorSettings extends
5213       com.google.protobuf.GeneratedMessage
5214       implements NetworkOperatorSettingsOrBuilder {
5215     // Use NetworkOperatorSettings.newBuilder() to construct.
5216     private NetworkOperatorSettings(Builder builder) {
5217       super(builder);
5218     }
5219     private NetworkOperatorSettings(boolean noInit) {}
5220
5221     private static final NetworkOperatorSettings defaultInstance;
5222     public static NetworkOperatorSettings getDefaultInstance() {
5223       return defaultInstance;
5224     }
5225
5226     public NetworkOperatorSettings getDefaultInstanceForType() {
5227       return defaultInstance;
5228     }
5229
5230     public static final com.google.protobuf.Descriptors.Descriptor
5231         getDescriptor() {
5232       return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_descriptor;
5233     }
5234
5235     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5236         internalGetFieldAccessorTable() {
5237       return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_fieldAccessorTable;
5238     }
5239
5240     public enum OperatorSelectMode
5241         implements com.google.protobuf.ProtocolMessageEnum {
5242       AUTOMATIC(0, 0),
5243       MANUAL(1, 1),
5244       DEREGISTER(2, 2),
5245       SET_ONLY(3, 3),
5246       MANUAL_AUTOMATIC(4, 4),
5247       ;
5248
5249       public static final int AUTOMATIC_VALUE = 0;
5250       public static final int MANUAL_VALUE = 1;
5251       public static final int DEREGISTER_VALUE = 2;
5252       public static final int SET_ONLY_VALUE = 3;
5253       public static final int MANUAL_AUTOMATIC_VALUE = 4;
5254
5255
5256       public final int getNumber() { return value; }
5257
5258       public static OperatorSelectMode valueOf(int value) {
5259         switch (value) {
5260           case 0: return AUTOMATIC;
5261           case 1: return MANUAL;
5262           case 2: return DEREGISTER;
5263           case 3: return SET_ONLY;
5264           case 4: return MANUAL_AUTOMATIC;
5265           default: return null;
5266         }
5267       }
5268
5269       public static com.google.protobuf.Internal.EnumLiteMap<OperatorSelectMode>
5270           internalGetValueMap() {
5271         return internalValueMap;
5272       }
5273       private static com.google.protobuf.Internal.EnumLiteMap<OperatorSelectMode>
5274           internalValueMap =
5275             new com.google.protobuf.Internal.EnumLiteMap<OperatorSelectMode>() {
5276               public OperatorSelectMode findValueByNumber(int number) {
5277                 return OperatorSelectMode.valueOf(number);
5278               }
5279             };
5280
5281       public final com.google.protobuf.Descriptors.EnumValueDescriptor
5282           getValueDescriptor() {
5283         return getDescriptor().getValues().get(index);
5284       }
5285       public final com.google.protobuf.Descriptors.EnumDescriptor
5286           getDescriptorForType() {
5287         return getDescriptor();
5288       }
5289       public static final com.google.protobuf.Descriptors.EnumDescriptor
5290           getDescriptor() {
5291         return com.openxc.BinaryMessages.NetworkOperatorSettings.getDescriptor().getEnumTypes().get(0);
5292       }
5293
5294       private static final OperatorSelectMode[] VALUES = {
5295         AUTOMATIC, MANUAL, DEREGISTER, SET_ONLY, MANUAL_AUTOMATIC,
5296       };
5297
5298       public static OperatorSelectMode valueOf(
5299           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
5300         if (desc.getType() != getDescriptor()) {
5301           throw new java.lang.IllegalArgumentException(
5302             "EnumValueDescriptor is not for this type.");
5303         }
5304         return VALUES[desc.getIndex()];
5305       }
5306
5307       private final int index;
5308       private final int value;
5309
5310       private OperatorSelectMode(int index, int value) {
5311         this.index = index;
5312         this.value = value;
5313       }
5314
5315       // @@protoc_insertion_point(enum_scope:openxc.NetworkOperatorSettings.OperatorSelectMode)
5316     }
5317
5318     public interface NetworkDescriptorOrBuilder
5319         extends com.google.protobuf.MessageOrBuilder {
5320
5321       // optional uint32 PLMN = 1;
5322       boolean hasPLMN();
5323       int getPLMN();
5324
5325       // optional .openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType = 2;
5326       boolean hasNetworkType();
5327       com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType getNetworkType();
5328     }
5329     public static final class NetworkDescriptor extends
5330         com.google.protobuf.GeneratedMessage
5331         implements NetworkDescriptorOrBuilder {
5332       // Use NetworkDescriptor.newBuilder() to construct.
5333       private NetworkDescriptor(Builder builder) {
5334         super(builder);
5335       }
5336       private NetworkDescriptor(boolean noInit) {}
5337
5338       private static final NetworkDescriptor defaultInstance;
5339       public static NetworkDescriptor getDefaultInstance() {
5340         return defaultInstance;
5341       }
5342
5343       public NetworkDescriptor getDefaultInstanceForType() {
5344         return defaultInstance;
5345       }
5346
5347       public static final com.google.protobuf.Descriptors.Descriptor
5348           getDescriptor() {
5349         return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_descriptor;
5350       }
5351
5352       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5353           internalGetFieldAccessorTable() {
5354         return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_fieldAccessorTable;
5355       }
5356
5357       public enum NetworkType
5358           implements com.google.protobuf.ProtocolMessageEnum {
5359         GSM(0, 0),
5360         UTRAN(1, 2),
5361         ;
5362
5363         public static final int GSM_VALUE = 0;
5364         public static final int UTRAN_VALUE = 2;
5365
5366
5367         public final int getNumber() { return value; }
5368
5369         public static NetworkType valueOf(int value) {
5370           switch (value) {
5371             case 0: return GSM;
5372             case 2: return UTRAN;
5373             default: return null;
5374           }
5375         }
5376
5377         public static com.google.protobuf.Internal.EnumLiteMap<NetworkType>
5378             internalGetValueMap() {
5379           return internalValueMap;
5380         }
5381         private static com.google.protobuf.Internal.EnumLiteMap<NetworkType>
5382             internalValueMap =
5383               new com.google.protobuf.Internal.EnumLiteMap<NetworkType>() {
5384                 public NetworkType findValueByNumber(int number) {
5385                   return NetworkType.valueOf(number);
5386                 }
5387               };
5388
5389         public final com.google.protobuf.Descriptors.EnumValueDescriptor
5390             getValueDescriptor() {
5391           return getDescriptor().getValues().get(index);
5392         }
5393         public final com.google.protobuf.Descriptors.EnumDescriptor
5394             getDescriptorForType() {
5395           return getDescriptor();
5396         }
5397         public static final com.google.protobuf.Descriptors.EnumDescriptor
5398             getDescriptor() {
5399           return com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.getDescriptor().getEnumTypes().get(0);
5400         }
5401
5402         private static final NetworkType[] VALUES = {
5403           GSM, UTRAN,
5404         };
5405
5406         public static NetworkType valueOf(
5407             com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
5408           if (desc.getType() != getDescriptor()) {
5409             throw new java.lang.IllegalArgumentException(
5410               "EnumValueDescriptor is not for this type.");
5411           }
5412           return VALUES[desc.getIndex()];
5413         }
5414
5415         private final int index;
5416         private final int value;
5417
5418         private NetworkType(int index, int value) {
5419           this.index = index;
5420           this.value = value;
5421         }
5422
5423         // @@protoc_insertion_point(enum_scope:openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType)
5424       }
5425
5426       private int bitField0_;
5427       // optional uint32 PLMN = 1;
5428       public static final int PLMN_FIELD_NUMBER = 1;
5429       private int pLMN_;
5430       public boolean hasPLMN() {
5431         return ((bitField0_ & 0x00000001) == 0x00000001);
5432       }
5433       public int getPLMN() {
5434         return pLMN_;
5435       }
5436
5437       // optional .openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType = 2;
5438       public static final int NETWORKTYPE_FIELD_NUMBER = 2;
5439       private com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType_;
5440       public boolean hasNetworkType() {
5441         return ((bitField0_ & 0x00000002) == 0x00000002);
5442       }
5443       public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType getNetworkType() {
5444         return networkType_;
5445       }
5446
5447       private void initFields() {
5448         pLMN_ = 0;
5449         networkType_ = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType.GSM;
5450       }
5451       private byte memoizedIsInitialized = -1;
5452       public final boolean isInitialized() {
5453         byte isInitialized = memoizedIsInitialized;
5454         if (isInitialized != -1) return isInitialized == 1;
5455
5456         memoizedIsInitialized = 1;
5457         return true;
5458       }
5459
5460       public void writeTo(com.google.protobuf.CodedOutputStream output)
5461                           throws java.io.IOException {
5462         getSerializedSize();
5463         if (((bitField0_ & 0x00000001) == 0x00000001)) {
5464           output.writeUInt32(1, pLMN_);
5465         }
5466         if (((bitField0_ & 0x00000002) == 0x00000002)) {
5467           output.writeEnum(2, networkType_.getNumber());
5468         }
5469         getUnknownFields().writeTo(output);
5470       }
5471
5472       private int memoizedSerializedSize = -1;
5473       public int getSerializedSize() {
5474         int size = memoizedSerializedSize;
5475         if (size != -1) return size;
5476
5477         size = 0;
5478         if (((bitField0_ & 0x00000001) == 0x00000001)) {
5479           size += com.google.protobuf.CodedOutputStream
5480             .computeUInt32Size(1, pLMN_);
5481         }
5482         if (((bitField0_ & 0x00000002) == 0x00000002)) {
5483           size += com.google.protobuf.CodedOutputStream
5484             .computeEnumSize(2, networkType_.getNumber());
5485         }
5486         size += getUnknownFields().getSerializedSize();
5487         memoizedSerializedSize = size;
5488         return size;
5489       }
5490
5491       private static final long serialVersionUID = 0L;
5492       @java.lang.Override
5493       protected java.lang.Object writeReplace()
5494           throws java.io.ObjectStreamException {
5495         return super.writeReplace();
5496       }
5497
5498       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseFrom(
5499           com.google.protobuf.ByteString data)
5500           throws com.google.protobuf.InvalidProtocolBufferException {
5501         return newBuilder().mergeFrom(data).buildParsed();
5502       }
5503       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseFrom(
5504           com.google.protobuf.ByteString data,
5505           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5506           throws com.google.protobuf.InvalidProtocolBufferException {
5507         return newBuilder().mergeFrom(data, extensionRegistry)
5508                  .buildParsed();
5509       }
5510       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseFrom(byte[] data)
5511           throws com.google.protobuf.InvalidProtocolBufferException {
5512         return newBuilder().mergeFrom(data).buildParsed();
5513       }
5514       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseFrom(
5515           byte[] data,
5516           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5517           throws com.google.protobuf.InvalidProtocolBufferException {
5518         return newBuilder().mergeFrom(data, extensionRegistry)
5519                  .buildParsed();
5520       }
5521       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseFrom(java.io.InputStream input)
5522           throws java.io.IOException {
5523         return newBuilder().mergeFrom(input).buildParsed();
5524       }
5525       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseFrom(
5526           java.io.InputStream input,
5527           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5528           throws java.io.IOException {
5529         return newBuilder().mergeFrom(input, extensionRegistry)
5530                  .buildParsed();
5531       }
5532       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseDelimitedFrom(java.io.InputStream input)
5533           throws java.io.IOException {
5534         Builder builder = newBuilder();
5535         if (builder.mergeDelimitedFrom(input)) {
5536           return builder.buildParsed();
5537         } else {
5538           return null;
5539         }
5540       }
5541       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseDelimitedFrom(
5542           java.io.InputStream input,
5543           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5544           throws java.io.IOException {
5545         Builder builder = newBuilder();
5546         if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
5547           return builder.buildParsed();
5548         } else {
5549           return null;
5550         }
5551       }
5552       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseFrom(
5553           com.google.protobuf.CodedInputStream input)
5554           throws java.io.IOException {
5555         return newBuilder().mergeFrom(input).buildParsed();
5556       }
5557       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseFrom(
5558           com.google.protobuf.CodedInputStream input,
5559           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5560           throws java.io.IOException {
5561         return newBuilder().mergeFrom(input, extensionRegistry)
5562                  .buildParsed();
5563       }
5564
5565       public static Builder newBuilder() { return Builder.create(); }
5566       public Builder newBuilderForType() { return newBuilder(); }
5567       public static Builder newBuilder(com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor prototype) {
5568         return newBuilder().mergeFrom(prototype);
5569       }
5570       public Builder toBuilder() { return newBuilder(this); }
5571
5572       @java.lang.Override
5573       protected Builder newBuilderForType(
5574           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5575         Builder builder = new Builder(parent);
5576         return builder;
5577       }
5578       public static final class Builder extends
5579           com.google.protobuf.GeneratedMessage.Builder<Builder>
5580          implements com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptorOrBuilder {
5581         public static final com.google.protobuf.Descriptors.Descriptor
5582             getDescriptor() {
5583           return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_descriptor;
5584         }
5585
5586         protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5587             internalGetFieldAccessorTable() {
5588           return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_fieldAccessorTable;
5589         }
5590
5591         // Construct using com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.newBuilder()
5592         private Builder() {
5593           maybeForceBuilderInitialization();
5594         }
5595
5596         private Builder(BuilderParent parent) {
5597           super(parent);
5598           maybeForceBuilderInitialization();
5599         }
5600         private void maybeForceBuilderInitialization() {
5601           if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
5602           }
5603         }
5604         private static Builder create() {
5605           return new Builder();
5606         }
5607
5608         public Builder clear() {
5609           super.clear();
5610           pLMN_ = 0;
5611           bitField0_ = (bitField0_ & ~0x00000001);
5612           networkType_ = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType.GSM;
5613           bitField0_ = (bitField0_ & ~0x00000002);
5614           return this;
5615         }
5616
5617         public Builder clone() {
5618           return create().mergeFrom(buildPartial());
5619         }
5620
5621         public com.google.protobuf.Descriptors.Descriptor
5622             getDescriptorForType() {
5623           return com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.getDescriptor();
5624         }
5625
5626         public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor getDefaultInstanceForType() {
5627           return com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.getDefaultInstance();
5628         }
5629
5630         public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor build() {
5631           com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor result = buildPartial();
5632           if (!result.isInitialized()) {
5633             throw newUninitializedMessageException(result);
5634           }
5635           return result;
5636         }
5637
5638         private com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor buildParsed()
5639             throws com.google.protobuf.InvalidProtocolBufferException {
5640           com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor result = buildPartial();
5641           if (!result.isInitialized()) {
5642             throw newUninitializedMessageException(
5643               result).asInvalidProtocolBufferException();
5644           }
5645           return result;
5646         }
5647
5648         public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor buildPartial() {
5649           com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor result = new com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor(this);
5650           int from_bitField0_ = bitField0_;
5651           int to_bitField0_ = 0;
5652           if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
5653             to_bitField0_ |= 0x00000001;
5654           }
5655           result.pLMN_ = pLMN_;
5656           if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
5657             to_bitField0_ |= 0x00000002;
5658           }
5659           result.networkType_ = networkType_;
5660           result.bitField0_ = to_bitField0_;
5661           onBuilt();
5662           return result;
5663         }
5664
5665         public Builder mergeFrom(com.google.protobuf.Message other) {
5666           if (other instanceof com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor) {
5667             return mergeFrom((com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor)other);
5668           } else {
5669             super.mergeFrom(other);
5670             return this;
5671           }
5672         }
5673
5674         public Builder mergeFrom(com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor other) {
5675           if (other == com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.getDefaultInstance()) return this;
5676           if (other.hasPLMN()) {
5677             setPLMN(other.getPLMN());
5678           }
5679           if (other.hasNetworkType()) {
5680             setNetworkType(other.getNetworkType());
5681           }
5682           this.mergeUnknownFields(other.getUnknownFields());
5683           return this;
5684         }
5685
5686         public final boolean isInitialized() {
5687           return true;
5688         }
5689
5690         public Builder mergeFrom(
5691             com.google.protobuf.CodedInputStream input,
5692             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5693             throws java.io.IOException {
5694           com.google.protobuf.UnknownFieldSet.Builder unknownFields =
5695             com.google.protobuf.UnknownFieldSet.newBuilder(
5696               this.getUnknownFields());
5697           while (true) {
5698             int tag = input.readTag();
5699             switch (tag) {
5700               case 0:
5701                 this.setUnknownFields(unknownFields.build());
5702                 onChanged();
5703                 return this;
5704               default: {
5705                 if (!parseUnknownField(input, unknownFields,
5706                                        extensionRegistry, tag)) {
5707                   this.setUnknownFields(unknownFields.build());
5708                   onChanged();
5709                   return this;
5710                 }
5711                 break;
5712               }
5713               case 8: {
5714                 bitField0_ |= 0x00000001;
5715                 pLMN_ = input.readUInt32();
5716                 break;
5717               }
5718               case 16: {
5719                 int rawValue = input.readEnum();
5720                 com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType value = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType.valueOf(rawValue);
5721                 if (value == null) {
5722                   unknownFields.mergeVarintField(2, rawValue);
5723                 } else {
5724                   bitField0_ |= 0x00000002;
5725                   networkType_ = value;
5726                 }
5727                 break;
5728               }
5729             }
5730           }
5731         }
5732
5733         private int bitField0_;
5734
5735         // optional uint32 PLMN = 1;
5736         private int pLMN_ ;
5737         public boolean hasPLMN() {
5738           return ((bitField0_ & 0x00000001) == 0x00000001);
5739         }
5740         public int getPLMN() {
5741           return pLMN_;
5742         }
5743         public Builder setPLMN(int value) {
5744           bitField0_ |= 0x00000001;
5745           pLMN_ = value;
5746           onChanged();
5747           return this;
5748         }
5749         public Builder clearPLMN() {
5750           bitField0_ = (bitField0_ & ~0x00000001);
5751           pLMN_ = 0;
5752           onChanged();
5753           return this;
5754         }
5755
5756         // optional .openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType = 2;
5757         private com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType_ = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType.GSM;
5758         public boolean hasNetworkType() {
5759           return ((bitField0_ & 0x00000002) == 0x00000002);
5760         }
5761         public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType getNetworkType() {
5762           return networkType_;
5763         }
5764         public Builder setNetworkType(com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType value) {
5765           if (value == null) {
5766             throw new NullPointerException();
5767           }
5768           bitField0_ |= 0x00000002;
5769           networkType_ = value;
5770           onChanged();
5771           return this;
5772         }
5773         public Builder clearNetworkType() {
5774           bitField0_ = (bitField0_ & ~0x00000002);
5775           networkType_ = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType.GSM;
5776           onChanged();
5777           return this;
5778         }
5779
5780         // @@protoc_insertion_point(builder_scope:openxc.NetworkOperatorSettings.NetworkDescriptor)
5781       }
5782
5783       static {
5784         defaultInstance = new NetworkDescriptor(true);
5785         defaultInstance.initFields();
5786       }
5787
5788       // @@protoc_insertion_point(class_scope:openxc.NetworkOperatorSettings.NetworkDescriptor)
5789     }
5790
5791     private int bitField0_;
5792     // optional bool allowDataRoaming = 1;
5793     public static final int ALLOWDATAROAMING_FIELD_NUMBER = 1;
5794     private boolean allowDataRoaming_;
5795     public boolean hasAllowDataRoaming() {
5796       return ((bitField0_ & 0x00000001) == 0x00000001);
5797     }
5798     public boolean getAllowDataRoaming() {
5799       return allowDataRoaming_;
5800     }
5801
5802     // optional .openxc.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode = 2;
5803     public static final int OPERATORSELECTMODE_FIELD_NUMBER = 2;
5804     private com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode_;
5805     public boolean hasOperatorSelectMode() {
5806       return ((bitField0_ & 0x00000002) == 0x00000002);
5807     }
5808     public com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode getOperatorSelectMode() {
5809       return operatorSelectMode_;
5810     }
5811
5812     // optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;
5813     public static final int NETWORKDESCRIPTOR_FIELD_NUMBER = 3;
5814     private com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor networkDescriptor_;
5815     public boolean hasNetworkDescriptor() {
5816       return ((bitField0_ & 0x00000004) == 0x00000004);
5817     }
5818     public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor getNetworkDescriptor() {
5819       return networkDescriptor_;
5820     }
5821     public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptorOrBuilder getNetworkDescriptorOrBuilder() {
5822       return networkDescriptor_;
5823     }
5824
5825     private void initFields() {
5826       allowDataRoaming_ = false;
5827       operatorSelectMode_ = com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode.AUTOMATIC;
5828       networkDescriptor_ = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.getDefaultInstance();
5829     }
5830     private byte memoizedIsInitialized = -1;
5831     public final boolean isInitialized() {
5832       byte isInitialized = memoizedIsInitialized;
5833       if (isInitialized != -1) return isInitialized == 1;
5834
5835       memoizedIsInitialized = 1;
5836       return true;
5837     }
5838
5839     public void writeTo(com.google.protobuf.CodedOutputStream output)
5840                         throws java.io.IOException {
5841       getSerializedSize();
5842       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5843         output.writeBool(1, allowDataRoaming_);
5844       }
5845       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5846         output.writeEnum(2, operatorSelectMode_.getNumber());
5847       }
5848       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5849         output.writeMessage(3, networkDescriptor_);
5850       }
5851       getUnknownFields().writeTo(output);
5852     }
5853
5854     private int memoizedSerializedSize = -1;
5855     public int getSerializedSize() {
5856       int size = memoizedSerializedSize;
5857       if (size != -1) return size;
5858
5859       size = 0;
5860       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5861         size += com.google.protobuf.CodedOutputStream
5862           .computeBoolSize(1, allowDataRoaming_);
5863       }
5864       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5865         size += com.google.protobuf.CodedOutputStream
5866           .computeEnumSize(2, operatorSelectMode_.getNumber());
5867       }
5868       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5869         size += com.google.protobuf.CodedOutputStream
5870           .computeMessageSize(3, networkDescriptor_);
5871       }
5872       size += getUnknownFields().getSerializedSize();
5873       memoizedSerializedSize = size;
5874       return size;
5875     }
5876
5877     private static final long serialVersionUID = 0L;
5878     @java.lang.Override
5879     protected java.lang.Object writeReplace()
5880         throws java.io.ObjectStreamException {
5881       return super.writeReplace();
5882     }
5883
5884     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseFrom(
5885         com.google.protobuf.ByteString data)
5886         throws com.google.protobuf.InvalidProtocolBufferException {
5887       return newBuilder().mergeFrom(data).buildParsed();
5888     }
5889     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseFrom(
5890         com.google.protobuf.ByteString data,
5891         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5892         throws com.google.protobuf.InvalidProtocolBufferException {
5893       return newBuilder().mergeFrom(data, extensionRegistry)
5894                .buildParsed();
5895     }
5896     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseFrom(byte[] data)
5897         throws com.google.protobuf.InvalidProtocolBufferException {
5898       return newBuilder().mergeFrom(data).buildParsed();
5899     }
5900     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseFrom(
5901         byte[] data,
5902         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5903         throws com.google.protobuf.InvalidProtocolBufferException {
5904       return newBuilder().mergeFrom(data, extensionRegistry)
5905                .buildParsed();
5906     }
5907     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseFrom(java.io.InputStream input)
5908         throws java.io.IOException {
5909       return newBuilder().mergeFrom(input).buildParsed();
5910     }
5911     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseFrom(
5912         java.io.InputStream input,
5913         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5914         throws java.io.IOException {
5915       return newBuilder().mergeFrom(input, extensionRegistry)
5916                .buildParsed();
5917     }
5918     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseDelimitedFrom(java.io.InputStream input)
5919         throws java.io.IOException {
5920       Builder builder = newBuilder();
5921       if (builder.mergeDelimitedFrom(input)) {
5922         return builder.buildParsed();
5923       } else {
5924         return null;
5925       }
5926     }
5927     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseDelimitedFrom(
5928         java.io.InputStream input,
5929         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5930         throws java.io.IOException {
5931       Builder builder = newBuilder();
5932       if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
5933         return builder.buildParsed();
5934       } else {
5935         return null;
5936       }
5937     }
5938     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseFrom(
5939         com.google.protobuf.CodedInputStream input)
5940         throws java.io.IOException {
5941       return newBuilder().mergeFrom(input).buildParsed();
5942     }
5943     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseFrom(
5944         com.google.protobuf.CodedInputStream input,
5945         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5946         throws java.io.IOException {
5947       return newBuilder().mergeFrom(input, extensionRegistry)
5948                .buildParsed();
5949     }
5950
5951     public static Builder newBuilder() { return Builder.create(); }
5952     public Builder newBuilderForType() { return newBuilder(); }
5953     public static Builder newBuilder(com.openxc.BinaryMessages.NetworkOperatorSettings prototype) {
5954       return newBuilder().mergeFrom(prototype);
5955     }
5956     public Builder toBuilder() { return newBuilder(this); }
5957
5958     @java.lang.Override
5959     protected Builder newBuilderForType(
5960         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5961       Builder builder = new Builder(parent);
5962       return builder;
5963     }
5964     public static final class Builder extends
5965         com.google.protobuf.GeneratedMessage.Builder<Builder>
5966        implements com.openxc.BinaryMessages.NetworkOperatorSettingsOrBuilder {
5967       public static final com.google.protobuf.Descriptors.Descriptor
5968           getDescriptor() {
5969         return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_descriptor;
5970       }
5971
5972       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5973           internalGetFieldAccessorTable() {
5974         return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_fieldAccessorTable;
5975       }
5976
5977       // Construct using com.openxc.BinaryMessages.NetworkOperatorSettings.newBuilder()
5978       private Builder() {
5979         maybeForceBuilderInitialization();
5980       }
5981
5982       private Builder(BuilderParent parent) {
5983         super(parent);
5984         maybeForceBuilderInitialization();
5985       }
5986       private void maybeForceBuilderInitialization() {
5987         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
5988           getNetworkDescriptorFieldBuilder();
5989         }
5990       }
5991       private static Builder create() {
5992         return new Builder();
5993       }
5994
5995       public Builder clear() {
5996         super.clear();
5997         allowDataRoaming_ = false;
5998         bitField0_ = (bitField0_ & ~0x00000001);
5999         operatorSelectMode_ = com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode.AUTOMATIC;
6000         bitField0_ = (bitField0_ & ~0x00000002);
6001         if (networkDescriptorBuilder_ == null) {
6002           networkDescriptor_ = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.getDefaultInstance();
6003         } else {
6004           networkDescriptorBuilder_.clear();
6005         }
6006         bitField0_ = (bitField0_ & ~0x00000004);
6007         return this;
6008       }
6009
6010       public Builder clone() {
6011         return create().mergeFrom(buildPartial());
6012       }
6013
6014       public com.google.protobuf.Descriptors.Descriptor
6015           getDescriptorForType() {
6016         return com.openxc.BinaryMessages.NetworkOperatorSettings.getDescriptor();
6017       }
6018
6019       public com.openxc.BinaryMessages.NetworkOperatorSettings getDefaultInstanceForType() {
6020         return com.openxc.BinaryMessages.NetworkOperatorSettings.getDefaultInstance();
6021       }
6022
6023       public com.openxc.BinaryMessages.NetworkOperatorSettings build() {
6024         com.openxc.BinaryMessages.NetworkOperatorSettings result = buildPartial();
6025         if (!result.isInitialized()) {
6026           throw newUninitializedMessageException(result);
6027         }
6028         return result;
6029       }
6030
6031       private com.openxc.BinaryMessages.NetworkOperatorSettings buildParsed()
6032           throws com.google.protobuf.InvalidProtocolBufferException {
6033         com.openxc.BinaryMessages.NetworkOperatorSettings result = buildPartial();
6034         if (!result.isInitialized()) {
6035           throw newUninitializedMessageException(
6036             result).asInvalidProtocolBufferException();
6037         }
6038         return result;
6039       }
6040
6041       public com.openxc.BinaryMessages.NetworkOperatorSettings buildPartial() {
6042         com.openxc.BinaryMessages.NetworkOperatorSettings result = new com.openxc.BinaryMessages.NetworkOperatorSettings(this);
6043         int from_bitField0_ = bitField0_;
6044         int to_bitField0_ = 0;
6045         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
6046           to_bitField0_ |= 0x00000001;
6047         }
6048         result.allowDataRoaming_ = allowDataRoaming_;
6049         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
6050           to_bitField0_ |= 0x00000002;
6051         }
6052         result.operatorSelectMode_ = operatorSelectMode_;
6053         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
6054           to_bitField0_ |= 0x00000004;
6055         }
6056         if (networkDescriptorBuilder_ == null) {
6057           result.networkDescriptor_ = networkDescriptor_;
6058         } else {
6059           result.networkDescriptor_ = networkDescriptorBuilder_.build();
6060         }
6061         result.bitField0_ = to_bitField0_;
6062         onBuilt();
6063         return result;
6064       }
6065
6066       public Builder mergeFrom(com.google.protobuf.Message other) {
6067         if (other instanceof com.openxc.BinaryMessages.NetworkOperatorSettings) {
6068           return mergeFrom((com.openxc.BinaryMessages.NetworkOperatorSettings)other);
6069         } else {
6070           super.mergeFrom(other);
6071           return this;
6072         }
6073       }
6074
6075       public Builder mergeFrom(com.openxc.BinaryMessages.NetworkOperatorSettings other) {
6076         if (other == com.openxc.BinaryMessages.NetworkOperatorSettings.getDefaultInstance()) return this;
6077         if (other.hasAllowDataRoaming()) {
6078           setAllowDataRoaming(other.getAllowDataRoaming());
6079         }
6080         if (other.hasOperatorSelectMode()) {
6081           setOperatorSelectMode(other.getOperatorSelectMode());
6082         }
6083         if (other.hasNetworkDescriptor()) {
6084           mergeNetworkDescriptor(other.getNetworkDescriptor());
6085         }
6086         this.mergeUnknownFields(other.getUnknownFields());
6087         return this;
6088       }
6089
6090       public final boolean isInitialized() {
6091         return true;
6092       }
6093
6094       public Builder mergeFrom(
6095           com.google.protobuf.CodedInputStream input,
6096           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6097           throws java.io.IOException {
6098         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
6099           com.google.protobuf.UnknownFieldSet.newBuilder(
6100             this.getUnknownFields());
6101         while (true) {
6102           int tag = input.readTag();
6103           switch (tag) {
6104             case 0:
6105               this.setUnknownFields(unknownFields.build());
6106               onChanged();
6107               return this;
6108             default: {
6109               if (!parseUnknownField(input, unknownFields,
6110                                      extensionRegistry, tag)) {
6111                 this.setUnknownFields(unknownFields.build());
6112                 onChanged();
6113                 return this;
6114               }
6115               break;
6116             }
6117             case 8: {
6118               bitField0_ |= 0x00000001;
6119               allowDataRoaming_ = input.readBool();
6120               break;
6121             }
6122             case 16: {
6123               int rawValue = input.readEnum();
6124               com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode value = com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode.valueOf(rawValue);
6125               if (value == null) {
6126                 unknownFields.mergeVarintField(2, rawValue);
6127               } else {
6128                 bitField0_ |= 0x00000002;
6129                 operatorSelectMode_ = value;
6130               }
6131               break;
6132             }
6133             case 26: {
6134               com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.Builder subBuilder = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.newBuilder();
6135               if (hasNetworkDescriptor()) {
6136                 subBuilder.mergeFrom(getNetworkDescriptor());
6137               }
6138               input.readMessage(subBuilder, extensionRegistry);
6139               setNetworkDescriptor(subBuilder.buildPartial());
6140               break;
6141             }
6142           }
6143         }
6144       }
6145
6146       private int bitField0_;
6147
6148       // optional bool allowDataRoaming = 1;
6149       private boolean allowDataRoaming_ ;
6150       public boolean hasAllowDataRoaming() {
6151         return ((bitField0_ & 0x00000001) == 0x00000001);
6152       }
6153       public boolean getAllowDataRoaming() {
6154         return allowDataRoaming_;
6155       }
6156       public Builder setAllowDataRoaming(boolean value) {
6157         bitField0_ |= 0x00000001;
6158         allowDataRoaming_ = value;
6159         onChanged();
6160         return this;
6161       }
6162       public Builder clearAllowDataRoaming() {
6163         bitField0_ = (bitField0_ & ~0x00000001);
6164         allowDataRoaming_ = false;
6165         onChanged();
6166         return this;
6167       }
6168
6169       // optional .openxc.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode = 2;
6170       private com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode_ = com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode.AUTOMATIC;
6171       public boolean hasOperatorSelectMode() {
6172         return ((bitField0_ & 0x00000002) == 0x00000002);
6173       }
6174       public com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode getOperatorSelectMode() {
6175         return operatorSelectMode_;
6176       }
6177       public Builder setOperatorSelectMode(com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode value) {
6178         if (value == null) {
6179           throw new NullPointerException();
6180         }
6181         bitField0_ |= 0x00000002;
6182         operatorSelectMode_ = value;
6183         onChanged();
6184         return this;
6185       }
6186       public Builder clearOperatorSelectMode() {
6187         bitField0_ = (bitField0_ & ~0x00000002);
6188         operatorSelectMode_ = com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode.AUTOMATIC;
6189         onChanged();
6190         return this;
6191       }
6192
6193       // optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;
6194       private com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor networkDescriptor_ = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.getDefaultInstance();
6195       private com.google.protobuf.SingleFieldBuilder<
6196           com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor, com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.Builder, com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptorOrBuilder> networkDescriptorBuilder_;
6197       public boolean hasNetworkDescriptor() {
6198         return ((bitField0_ & 0x00000004) == 0x00000004);
6199       }
6200       public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor getNetworkDescriptor() {
6201         if (networkDescriptorBuilder_ == null) {
6202           return networkDescriptor_;
6203         } else {
6204           return networkDescriptorBuilder_.getMessage();
6205         }
6206       }
6207       public Builder setNetworkDescriptor(com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor value) {
6208         if (networkDescriptorBuilder_ == null) {
6209           if (value == null) {
6210             throw new NullPointerException();
6211           }
6212           networkDescriptor_ = value;
6213           onChanged();
6214         } else {
6215           networkDescriptorBuilder_.setMessage(value);
6216         }
6217         bitField0_ |= 0x00000004;
6218         return this;
6219       }
6220       public Builder setNetworkDescriptor(
6221           com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.Builder builderForValue) {
6222         if (networkDescriptorBuilder_ == null) {
6223           networkDescriptor_ = builderForValue.build();
6224           onChanged();
6225         } else {
6226           networkDescriptorBuilder_.setMessage(builderForValue.build());
6227         }
6228         bitField0_ |= 0x00000004;
6229         return this;
6230       }
6231       public Builder mergeNetworkDescriptor(com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor value) {
6232         if (networkDescriptorBuilder_ == null) {
6233           if (((bitField0_ & 0x00000004) == 0x00000004) &&
6234               networkDescriptor_ != com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.getDefaultInstance()) {
6235             networkDescriptor_ =
6236               com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.newBuilder(networkDescriptor_).mergeFrom(value).buildPartial();
6237           } else {
6238             networkDescriptor_ = value;
6239           }
6240           onChanged();
6241         } else {
6242           networkDescriptorBuilder_.mergeFrom(value);
6243         }
6244         bitField0_ |= 0x00000004;
6245         return this;
6246       }
6247       public Builder clearNetworkDescriptor() {
6248         if (networkDescriptorBuilder_ == null) {
6249           networkDescriptor_ = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.getDefaultInstance();
6250           onChanged();
6251         } else {
6252           networkDescriptorBuilder_.clear();
6253         }
6254         bitField0_ = (bitField0_ & ~0x00000004);
6255         return this;
6256       }
6257       public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.Builder getNetworkDescriptorBuilder() {
6258         bitField0_ |= 0x00000004;
6259         onChanged();
6260         return getNetworkDescriptorFieldBuilder().getBuilder();
6261       }
6262       public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptorOrBuilder getNetworkDescriptorOrBuilder() {
6263         if (networkDescriptorBuilder_ != null) {
6264           return networkDescriptorBuilder_.getMessageOrBuilder();
6265         } else {
6266           return networkDescriptor_;
6267         }
6268       }
6269       private com.google.protobuf.SingleFieldBuilder<
6270           com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor, com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.Builder, com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptorOrBuilder>
6271           getNetworkDescriptorFieldBuilder() {
6272         if (networkDescriptorBuilder_ == null) {
6273           networkDescriptorBuilder_ = new com.google.protobuf.SingleFieldBuilder<
6274               com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor, com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.Builder, com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptorOrBuilder>(
6275                   networkDescriptor_,
6276                   getParentForChildren(),
6277                   isClean());
6278           networkDescriptor_ = null;
6279         }
6280         return networkDescriptorBuilder_;
6281       }
6282
6283       // @@protoc_insertion_point(builder_scope:openxc.NetworkOperatorSettings)
6284     }
6285
6286     static {
6287       defaultInstance = new NetworkOperatorSettings(true);
6288       defaultInstance.initFields();
6289     }
6290
6291     // @@protoc_insertion_point(class_scope:openxc.NetworkOperatorSettings)
6292   }
6293
6294   public interface NetworkDataSettingsOrBuilder
6295       extends com.google.protobuf.MessageOrBuilder {
6296
6297     // optional string APN = 1;
6298     boolean hasAPN();
6299     String getAPN();
6300   }
6301   public static final class NetworkDataSettings extends
6302       com.google.protobuf.GeneratedMessage
6303       implements NetworkDataSettingsOrBuilder {
6304     // Use NetworkDataSettings.newBuilder() to construct.
6305     private NetworkDataSettings(Builder builder) {
6306       super(builder);
6307     }
6308     private NetworkDataSettings(boolean noInit) {}
6309
6310     private static final NetworkDataSettings defaultInstance;
6311     public static NetworkDataSettings getDefaultInstance() {
6312       return defaultInstance;
6313     }
6314
6315     public NetworkDataSettings getDefaultInstanceForType() {
6316       return defaultInstance;
6317     }
6318
6319     public static final com.google.protobuf.Descriptors.Descriptor
6320         getDescriptor() {
6321       return com.openxc.BinaryMessages.internal_static_openxc_NetworkDataSettings_descriptor;
6322     }
6323
6324     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6325         internalGetFieldAccessorTable() {
6326       return com.openxc.BinaryMessages.internal_static_openxc_NetworkDataSettings_fieldAccessorTable;
6327     }
6328
6329     private int bitField0_;
6330     // optional string APN = 1;
6331     public static final int APN_FIELD_NUMBER = 1;
6332     private java.lang.Object aPN_;
6333     public boolean hasAPN() {
6334       return ((bitField0_ & 0x00000001) == 0x00000001);
6335     }
6336     public String getAPN() {
6337       java.lang.Object ref = aPN_;
6338       if (ref instanceof String) {
6339         return (String) ref;
6340       } else {
6341         com.google.protobuf.ByteString bs =
6342             (com.google.protobuf.ByteString) ref;
6343         String s = bs.toStringUtf8();
6344         if (com.google.protobuf.Internal.isValidUtf8(bs)) {
6345           aPN_ = s;
6346         }
6347         return s;
6348       }
6349     }
6350     private com.google.protobuf.ByteString getAPNBytes() {
6351       java.lang.Object ref = aPN_;
6352       if (ref instanceof String) {
6353         com.google.protobuf.ByteString b =
6354             com.google.protobuf.ByteString.copyFromUtf8((String) ref);
6355         aPN_ = b;
6356         return b;
6357       } else {
6358         return (com.google.protobuf.ByteString) ref;
6359       }
6360     }
6361
6362     private void initFields() {
6363       aPN_ = "";
6364     }
6365     private byte memoizedIsInitialized = -1;
6366     public final boolean isInitialized() {
6367       byte isInitialized = memoizedIsInitialized;
6368       if (isInitialized != -1) return isInitialized == 1;
6369
6370       memoizedIsInitialized = 1;
6371       return true;
6372     }
6373
6374     public void writeTo(com.google.protobuf.CodedOutputStream output)
6375                         throws java.io.IOException {
6376       getSerializedSize();
6377       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6378         output.writeBytes(1, getAPNBytes());
6379       }
6380       getUnknownFields().writeTo(output);
6381     }
6382
6383     private int memoizedSerializedSize = -1;
6384     public int getSerializedSize() {
6385       int size = memoizedSerializedSize;
6386       if (size != -1) return size;
6387
6388       size = 0;
6389       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6390         size += com.google.protobuf.CodedOutputStream
6391           .computeBytesSize(1, getAPNBytes());
6392       }
6393       size += getUnknownFields().getSerializedSize();
6394       memoizedSerializedSize = size;
6395       return size;
6396     }
6397
6398     private static final long serialVersionUID = 0L;
6399     @java.lang.Override
6400     protected java.lang.Object writeReplace()
6401         throws java.io.ObjectStreamException {
6402       return super.writeReplace();
6403     }
6404
6405     public static com.openxc.BinaryMessages.NetworkDataSettings parseFrom(
6406         com.google.protobuf.ByteString data)
6407         throws com.google.protobuf.InvalidProtocolBufferException {
6408       return newBuilder().mergeFrom(data).buildParsed();
6409     }
6410     public static com.openxc.BinaryMessages.NetworkDataSettings parseFrom(
6411         com.google.protobuf.ByteString data,
6412         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6413         throws com.google.protobuf.InvalidProtocolBufferException {
6414       return newBuilder().mergeFrom(data, extensionRegistry)
6415                .buildParsed();
6416     }
6417     public static com.openxc.BinaryMessages.NetworkDataSettings parseFrom(byte[] data)
6418         throws com.google.protobuf.InvalidProtocolBufferException {
6419       return newBuilder().mergeFrom(data).buildParsed();
6420     }
6421     public static com.openxc.BinaryMessages.NetworkDataSettings parseFrom(
6422         byte[] data,
6423         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6424         throws com.google.protobuf.InvalidProtocolBufferException {
6425       return newBuilder().mergeFrom(data, extensionRegistry)
6426                .buildParsed();
6427     }
6428     public static com.openxc.BinaryMessages.NetworkDataSettings parseFrom(java.io.InputStream input)
6429         throws java.io.IOException {
6430       return newBuilder().mergeFrom(input).buildParsed();
6431     }
6432     public static com.openxc.BinaryMessages.NetworkDataSettings parseFrom(
6433         java.io.InputStream input,
6434         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6435         throws java.io.IOException {
6436       return newBuilder().mergeFrom(input, extensionRegistry)
6437                .buildParsed();
6438     }
6439     public static com.openxc.BinaryMessages.NetworkDataSettings parseDelimitedFrom(java.io.InputStream input)
6440         throws java.io.IOException {
6441       Builder builder = newBuilder();
6442       if (builder.mergeDelimitedFrom(input)) {
6443         return builder.buildParsed();
6444       } else {
6445         return null;
6446       }
6447     }
6448     public static com.openxc.BinaryMessages.NetworkDataSettings parseDelimitedFrom(
6449         java.io.InputStream input,
6450         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6451         throws java.io.IOException {
6452       Builder builder = newBuilder();
6453       if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
6454         return builder.buildParsed();
6455       } else {
6456         return null;
6457       }
6458     }
6459     public static com.openxc.BinaryMessages.NetworkDataSettings parseFrom(
6460         com.google.protobuf.CodedInputStream input)
6461         throws java.io.IOException {
6462       return newBuilder().mergeFrom(input).buildParsed();
6463     }
6464     public static com.openxc.BinaryMessages.NetworkDataSettings parseFrom(
6465         com.google.protobuf.CodedInputStream input,
6466         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6467         throws java.io.IOException {
6468       return newBuilder().mergeFrom(input, extensionRegistry)
6469                .buildParsed();
6470     }
6471
6472     public static Builder newBuilder() { return Builder.create(); }
6473     public Builder newBuilderForType() { return newBuilder(); }
6474     public static Builder newBuilder(com.openxc.BinaryMessages.NetworkDataSettings prototype) {
6475       return newBuilder().mergeFrom(prototype);
6476     }
6477     public Builder toBuilder() { return newBuilder(this); }
6478
6479     @java.lang.Override
6480     protected Builder newBuilderForType(
6481         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6482       Builder builder = new Builder(parent);
6483       return builder;
6484     }
6485     public static final class Builder extends
6486         com.google.protobuf.GeneratedMessage.Builder<Builder>
6487        implements com.openxc.BinaryMessages.NetworkDataSettingsOrBuilder {
6488       public static final com.google.protobuf.Descriptors.Descriptor
6489           getDescriptor() {
6490         return com.openxc.BinaryMessages.internal_static_openxc_NetworkDataSettings_descriptor;
6491       }
6492
6493       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6494           internalGetFieldAccessorTable() {
6495         return com.openxc.BinaryMessages.internal_static_openxc_NetworkDataSettings_fieldAccessorTable;
6496       }
6497
6498       // Construct using com.openxc.BinaryMessages.NetworkDataSettings.newBuilder()
6499       private Builder() {
6500         maybeForceBuilderInitialization();
6501       }
6502
6503       private Builder(BuilderParent parent) {
6504         super(parent);
6505         maybeForceBuilderInitialization();
6506       }
6507       private void maybeForceBuilderInitialization() {
6508         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
6509         }
6510       }
6511       private static Builder create() {
6512         return new Builder();
6513       }
6514
6515       public Builder clear() {
6516         super.clear();
6517         aPN_ = "";
6518         bitField0_ = (bitField0_ & ~0x00000001);
6519         return this;
6520       }
6521
6522       public Builder clone() {
6523         return create().mergeFrom(buildPartial());
6524       }
6525
6526       public com.google.protobuf.Descriptors.Descriptor
6527           getDescriptorForType() {
6528         return com.openxc.BinaryMessages.NetworkDataSettings.getDescriptor();
6529       }
6530
6531       public com.openxc.BinaryMessages.NetworkDataSettings getDefaultInstanceForType() {
6532         return com.openxc.BinaryMessages.NetworkDataSettings.getDefaultInstance();
6533       }
6534
6535       public com.openxc.BinaryMessages.NetworkDataSettings build() {
6536         com.openxc.BinaryMessages.NetworkDataSettings result = buildPartial();
6537         if (!result.isInitialized()) {
6538           throw newUninitializedMessageException(result);
6539         }
6540         return result;
6541       }
6542
6543       private com.openxc.BinaryMessages.NetworkDataSettings buildParsed()
6544           throws com.google.protobuf.InvalidProtocolBufferException {
6545         com.openxc.BinaryMessages.NetworkDataSettings result = buildPartial();
6546         if (!result.isInitialized()) {
6547           throw newUninitializedMessageException(
6548             result).asInvalidProtocolBufferException();
6549         }
6550         return result;
6551       }
6552
6553       public com.openxc.BinaryMessages.NetworkDataSettings buildPartial() {
6554         com.openxc.BinaryMessages.NetworkDataSettings result = new com.openxc.BinaryMessages.NetworkDataSettings(this);
6555         int from_bitField0_ = bitField0_;
6556         int to_bitField0_ = 0;
6557         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
6558           to_bitField0_ |= 0x00000001;
6559         }
6560         result.aPN_ = aPN_;
6561         result.bitField0_ = to_bitField0_;
6562         onBuilt();
6563         return result;
6564       }
6565
6566       public Builder mergeFrom(com.google.protobuf.Message other) {
6567         if (other instanceof com.openxc.BinaryMessages.NetworkDataSettings) {
6568           return mergeFrom((com.openxc.BinaryMessages.NetworkDataSettings)other);
6569         } else {
6570           super.mergeFrom(other);
6571           return this;
6572         }
6573       }
6574
6575       public Builder mergeFrom(com.openxc.BinaryMessages.NetworkDataSettings other) {
6576         if (other == com.openxc.BinaryMessages.NetworkDataSettings.getDefaultInstance()) return this;
6577         if (other.hasAPN()) {
6578           setAPN(other.getAPN());
6579         }
6580         this.mergeUnknownFields(other.getUnknownFields());
6581         return this;
6582       }
6583
6584       public final boolean isInitialized() {
6585         return true;
6586       }
6587
6588       public Builder mergeFrom(
6589           com.google.protobuf.CodedInputStream input,
6590           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6591           throws java.io.IOException {
6592         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
6593           com.google.protobuf.UnknownFieldSet.newBuilder(
6594             this.getUnknownFields());
6595         while (true) {
6596           int tag = input.readTag();
6597           switch (tag) {
6598             case 0:
6599               this.setUnknownFields(unknownFields.build());
6600               onChanged();
6601               return this;
6602             default: {
6603               if (!parseUnknownField(input, unknownFields,
6604                                      extensionRegistry, tag)) {
6605                 this.setUnknownFields(unknownFields.build());
6606                 onChanged();
6607                 return this;
6608               }
6609               break;
6610             }
6611             case 10: {
6612               bitField0_ |= 0x00000001;
6613               aPN_ = input.readBytes();
6614               break;
6615             }
6616           }
6617         }
6618       }
6619
6620       private int bitField0_;
6621
6622       // optional string APN = 1;
6623       private java.lang.Object aPN_ = "";
6624       public boolean hasAPN() {
6625         return ((bitField0_ & 0x00000001) == 0x00000001);
6626       }
6627       public String getAPN() {
6628         java.lang.Object ref = aPN_;
6629         if (!(ref instanceof String)) {
6630           String s = ((com.google.protobuf.ByteString) ref).toStringUtf8();
6631           aPN_ = s;
6632           return s;
6633         } else {
6634           return (String) ref;
6635         }
6636       }
6637       public Builder setAPN(String value) {
6638         if (value == null) {
6639     throw new NullPointerException();
6640   }
6641   bitField0_ |= 0x00000001;
6642         aPN_ = value;
6643         onChanged();
6644         return this;
6645       }
6646       public Builder clearAPN() {
6647         bitField0_ = (bitField0_ & ~0x00000001);
6648         aPN_ = getDefaultInstance().getAPN();
6649         onChanged();
6650         return this;
6651       }
6652       void setAPN(com.google.protobuf.ByteString value) {
6653         bitField0_ |= 0x00000001;
6654         aPN_ = value;
6655         onChanged();
6656       }
6657
6658       // @@protoc_insertion_point(builder_scope:openxc.NetworkDataSettings)
6659     }
6660
6661     static {
6662       defaultInstance = new NetworkDataSettings(true);
6663       defaultInstance.initFields();
6664     }
6665
6666     // @@protoc_insertion_point(class_scope:openxc.NetworkDataSettings)
6667   }
6668
6669   public interface ServerConnectSettingsOrBuilder
6670       extends com.google.protobuf.MessageOrBuilder {
6671
6672     // optional string host = 1;
6673     boolean hasHost();
6674     String getHost();
6675
6676     // optional uint32 port = 2;
6677     boolean hasPort();
6678     int getPort();
6679   }
6680   public static final class ServerConnectSettings extends
6681       com.google.protobuf.GeneratedMessage
6682       implements ServerConnectSettingsOrBuilder {
6683     // Use ServerConnectSettings.newBuilder() to construct.
6684     private ServerConnectSettings(Builder builder) {
6685       super(builder);
6686     }
6687     private ServerConnectSettings(boolean noInit) {}
6688
6689     private static final ServerConnectSettings defaultInstance;
6690     public static ServerConnectSettings getDefaultInstance() {
6691       return defaultInstance;
6692     }
6693
6694     public ServerConnectSettings getDefaultInstanceForType() {
6695       return defaultInstance;
6696     }
6697
6698     public static final com.google.protobuf.Descriptors.Descriptor
6699         getDescriptor() {
6700       return com.openxc.BinaryMessages.internal_static_openxc_ServerConnectSettings_descriptor;
6701     }
6702
6703     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6704         internalGetFieldAccessorTable() {
6705       return com.openxc.BinaryMessages.internal_static_openxc_ServerConnectSettings_fieldAccessorTable;
6706     }
6707
6708     private int bitField0_;
6709     // optional string host = 1;
6710     public static final int HOST_FIELD_NUMBER = 1;
6711     private java.lang.Object host_;
6712     public boolean hasHost() {
6713       return ((bitField0_ & 0x00000001) == 0x00000001);
6714     }
6715     public String getHost() {
6716       java.lang.Object ref = host_;
6717       if (ref instanceof String) {
6718         return (String) ref;
6719       } else {
6720         com.google.protobuf.ByteString bs =
6721             (com.google.protobuf.ByteString) ref;
6722         String s = bs.toStringUtf8();
6723         if (com.google.protobuf.Internal.isValidUtf8(bs)) {
6724           host_ = s;
6725         }
6726         return s;
6727       }
6728     }
6729     private com.google.protobuf.ByteString getHostBytes() {
6730       java.lang.Object ref = host_;
6731       if (ref instanceof String) {
6732         com.google.protobuf.ByteString b =
6733             com.google.protobuf.ByteString.copyFromUtf8((String) ref);
6734         host_ = b;
6735         return b;
6736       } else {
6737         return (com.google.protobuf.ByteString) ref;
6738       }
6739     }
6740
6741     // optional uint32 port = 2;
6742     public static final int PORT_FIELD_NUMBER = 2;
6743     private int port_;
6744     public boolean hasPort() {
6745       return ((bitField0_ & 0x00000002) == 0x00000002);
6746     }
6747     public int getPort() {
6748       return port_;
6749     }
6750
6751     private void initFields() {
6752       host_ = "";
6753       port_ = 0;
6754     }
6755     private byte memoizedIsInitialized = -1;
6756     public final boolean isInitialized() {
6757       byte isInitialized = memoizedIsInitialized;
6758       if (isInitialized != -1) return isInitialized == 1;
6759
6760       memoizedIsInitialized = 1;
6761       return true;
6762     }
6763
6764     public void writeTo(com.google.protobuf.CodedOutputStream output)
6765                         throws java.io.IOException {
6766       getSerializedSize();
6767       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6768         output.writeBytes(1, getHostBytes());
6769       }
6770       if (((bitField0_ & 0x00000002) == 0x00000002)) {
6771         output.writeUInt32(2, port_);
6772       }
6773       getUnknownFields().writeTo(output);
6774     }
6775
6776     private int memoizedSerializedSize = -1;
6777     public int getSerializedSize() {
6778       int size = memoizedSerializedSize;
6779       if (size != -1) return size;
6780
6781       size = 0;
6782       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6783         size += com.google.protobuf.CodedOutputStream
6784           .computeBytesSize(1, getHostBytes());
6785       }
6786       if (((bitField0_ & 0x00000002) == 0x00000002)) {
6787         size += com.google.protobuf.CodedOutputStream
6788           .computeUInt32Size(2, port_);
6789       }
6790       size += getUnknownFields().getSerializedSize();
6791       memoizedSerializedSize = size;
6792       return size;
6793     }
6794
6795     private static final long serialVersionUID = 0L;
6796     @java.lang.Override
6797     protected java.lang.Object writeReplace()
6798         throws java.io.ObjectStreamException {
6799       return super.writeReplace();
6800     }
6801
6802     public static com.openxc.BinaryMessages.ServerConnectSettings parseFrom(
6803         com.google.protobuf.ByteString data)
6804         throws com.google.protobuf.InvalidProtocolBufferException {
6805       return newBuilder().mergeFrom(data).buildParsed();
6806     }
6807     public static com.openxc.BinaryMessages.ServerConnectSettings parseFrom(
6808         com.google.protobuf.ByteString data,
6809         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6810         throws com.google.protobuf.InvalidProtocolBufferException {
6811       return newBuilder().mergeFrom(data, extensionRegistry)
6812                .buildParsed();
6813     }
6814     public static com.openxc.BinaryMessages.ServerConnectSettings parseFrom(byte[] data)
6815         throws com.google.protobuf.InvalidProtocolBufferException {
6816       return newBuilder().mergeFrom(data).buildParsed();
6817     }
6818     public static com.openxc.BinaryMessages.ServerConnectSettings parseFrom(
6819         byte[] data,
6820         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6821         throws com.google.protobuf.InvalidProtocolBufferException {
6822       return newBuilder().mergeFrom(data, extensionRegistry)
6823                .buildParsed();
6824     }
6825     public static com.openxc.BinaryMessages.ServerConnectSettings parseFrom(java.io.InputStream input)
6826         throws java.io.IOException {
6827       return newBuilder().mergeFrom(input).buildParsed();
6828     }
6829     public static com.openxc.BinaryMessages.ServerConnectSettings parseFrom(
6830         java.io.InputStream input,
6831         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6832         throws java.io.IOException {
6833       return newBuilder().mergeFrom(input, extensionRegistry)
6834                .buildParsed();
6835     }
6836     public static com.openxc.BinaryMessages.ServerConnectSettings parseDelimitedFrom(java.io.InputStream input)
6837         throws java.io.IOException {
6838       Builder builder = newBuilder();
6839       if (builder.mergeDelimitedFrom(input)) {
6840         return builder.buildParsed();
6841       } else {
6842         return null;
6843       }
6844     }
6845     public static com.openxc.BinaryMessages.ServerConnectSettings parseDelimitedFrom(
6846         java.io.InputStream input,
6847         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6848         throws java.io.IOException {
6849       Builder builder = newBuilder();
6850       if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
6851         return builder.buildParsed();
6852       } else {
6853         return null;
6854       }
6855     }
6856     public static com.openxc.BinaryMessages.ServerConnectSettings parseFrom(
6857         com.google.protobuf.CodedInputStream input)
6858         throws java.io.IOException {
6859       return newBuilder().mergeFrom(input).buildParsed();
6860     }
6861     public static com.openxc.BinaryMessages.ServerConnectSettings parseFrom(
6862         com.google.protobuf.CodedInputStream input,
6863         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6864         throws java.io.IOException {
6865       return newBuilder().mergeFrom(input, extensionRegistry)
6866                .buildParsed();
6867     }
6868
6869     public static Builder newBuilder() { return Builder.create(); }
6870     public Builder newBuilderForType() { return newBuilder(); }
6871     public static Builder newBuilder(com.openxc.BinaryMessages.ServerConnectSettings prototype) {
6872       return newBuilder().mergeFrom(prototype);
6873     }
6874     public Builder toBuilder() { return newBuilder(this); }
6875
6876     @java.lang.Override
6877     protected Builder newBuilderForType(
6878         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6879       Builder builder = new Builder(parent);
6880       return builder;
6881     }
6882     public static final class Builder extends
6883         com.google.protobuf.GeneratedMessage.Builder<Builder>
6884        implements com.openxc.BinaryMessages.ServerConnectSettingsOrBuilder {
6885       public static final com.google.protobuf.Descriptors.Descriptor
6886           getDescriptor() {
6887         return com.openxc.BinaryMessages.internal_static_openxc_ServerConnectSettings_descriptor;
6888       }
6889
6890       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6891           internalGetFieldAccessorTable() {
6892         return com.openxc.BinaryMessages.internal_static_openxc_ServerConnectSettings_fieldAccessorTable;
6893       }
6894
6895       // Construct using com.openxc.BinaryMessages.ServerConnectSettings.newBuilder()
6896       private Builder() {
6897         maybeForceBuilderInitialization();
6898       }
6899
6900       private Builder(BuilderParent parent) {
6901         super(parent);
6902         maybeForceBuilderInitialization();
6903       }
6904       private void maybeForceBuilderInitialization() {
6905         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
6906         }
6907       }
6908       private static Builder create() {
6909         return new Builder();
6910       }
6911
6912       public Builder clear() {
6913         super.clear();
6914         host_ = "";
6915         bitField0_ = (bitField0_ & ~0x00000001);
6916         port_ = 0;
6917         bitField0_ = (bitField0_ & ~0x00000002);
6918         return this;
6919       }
6920
6921       public Builder clone() {
6922         return create().mergeFrom(buildPartial());
6923       }
6924
6925       public com.google.protobuf.Descriptors.Descriptor
6926           getDescriptorForType() {
6927         return com.openxc.BinaryMessages.ServerConnectSettings.getDescriptor();
6928       }
6929
6930       public com.openxc.BinaryMessages.ServerConnectSettings getDefaultInstanceForType() {
6931         return com.openxc.BinaryMessages.ServerConnectSettings.getDefaultInstance();
6932       }
6933
6934       public com.openxc.BinaryMessages.ServerConnectSettings build() {
6935         com.openxc.BinaryMessages.ServerConnectSettings result = buildPartial();
6936         if (!result.isInitialized()) {
6937           throw newUninitializedMessageException(result);
6938         }
6939         return result;
6940       }
6941
6942       private com.openxc.BinaryMessages.ServerConnectSettings buildParsed()
6943           throws com.google.protobuf.InvalidProtocolBufferException {
6944         com.openxc.BinaryMessages.ServerConnectSettings result = buildPartial();
6945         if (!result.isInitialized()) {
6946           throw newUninitializedMessageException(
6947             result).asInvalidProtocolBufferException();
6948         }
6949         return result;
6950       }
6951
6952       public com.openxc.BinaryMessages.ServerConnectSettings buildPartial() {
6953         com.openxc.BinaryMessages.ServerConnectSettings result = new com.openxc.BinaryMessages.ServerConnectSettings(this);
6954         int from_bitField0_ = bitField0_;
6955         int to_bitField0_ = 0;
6956         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
6957           to_bitField0_ |= 0x00000001;
6958         }
6959         result.host_ = host_;
6960         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
6961           to_bitField0_ |= 0x00000002;
6962         }
6963         result.port_ = port_;
6964         result.bitField0_ = to_bitField0_;
6965         onBuilt();
6966         return result;
6967       }
6968
6969       public Builder mergeFrom(com.google.protobuf.Message other) {
6970         if (other instanceof com.openxc.BinaryMessages.ServerConnectSettings) {
6971           return mergeFrom((com.openxc.BinaryMessages.ServerConnectSettings)other);
6972         } else {
6973           super.mergeFrom(other);
6974           return this;
6975         }
6976       }
6977
6978       public Builder mergeFrom(com.openxc.BinaryMessages.ServerConnectSettings other) {
6979         if (other == com.openxc.BinaryMessages.ServerConnectSettings.getDefaultInstance()) return this;
6980         if (other.hasHost()) {
6981           setHost(other.getHost());
6982         }
6983         if (other.hasPort()) {
6984           setPort(other.getPort());
6985         }
6986         this.mergeUnknownFields(other.getUnknownFields());
6987         return this;
6988       }
6989
6990       public final boolean isInitialized() {
6991         return true;
6992       }
6993
6994       public Builder mergeFrom(
6995           com.google.protobuf.CodedInputStream input,
6996           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6997           throws java.io.IOException {
6998         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
6999           com.google.protobuf.UnknownFieldSet.newBuilder(
7000             this.getUnknownFields());
7001         while (true) {
7002           int tag = input.readTag();
7003           switch (tag) {
7004             case 0:
7005               this.setUnknownFields(unknownFields.build());
7006               onChanged();
7007               return this;
7008             default: {
7009               if (!parseUnknownField(input, unknownFields,
7010                                      extensionRegistry, tag)) {
7011                 this.setUnknownFields(unknownFields.build());
7012                 onChanged();
7013                 return this;
7014               }
7015               break;
7016             }
7017             case 10: {
7018               bitField0_ |= 0x00000001;
7019               host_ = input.readBytes();
7020               break;
7021             }
7022             case 16: {
7023               bitField0_ |= 0x00000002;
7024               port_ = input.readUInt32();
7025               break;
7026             }
7027           }
7028         }
7029       }
7030
7031       private int bitField0_;
7032
7033       // optional string host = 1;
7034       private java.lang.Object host_ = "";
7035       public boolean hasHost() {
7036         return ((bitField0_ & 0x00000001) == 0x00000001);
7037       }
7038       public String getHost() {
7039         java.lang.Object ref = host_;
7040         if (!(ref instanceof String)) {
7041           String s = ((com.google.protobuf.ByteString) ref).toStringUtf8();
7042           host_ = s;
7043           return s;
7044         } else {
7045           return (String) ref;
7046         }
7047       }
7048       public Builder setHost(String value) {
7049         if (value == null) {
7050     throw new NullPointerException();
7051   }
7052   bitField0_ |= 0x00000001;
7053         host_ = value;
7054         onChanged();
7055         return this;
7056       }
7057       public Builder clearHost() {
7058         bitField0_ = (bitField0_ & ~0x00000001);
7059         host_ = getDefaultInstance().getHost();
7060         onChanged();
7061         return this;
7062       }
7063       void setHost(com.google.protobuf.ByteString value) {
7064         bitField0_ |= 0x00000001;
7065         host_ = value;
7066         onChanged();
7067       }
7068
7069       // optional uint32 port = 2;
7070       private int port_ ;
7071       public boolean hasPort() {
7072         return ((bitField0_ & 0x00000002) == 0x00000002);
7073       }
7074       public int getPort() {
7075         return port_;
7076       }
7077       public Builder setPort(int value) {
7078         bitField0_ |= 0x00000002;
7079         port_ = value;
7080         onChanged();
7081         return this;
7082       }
7083       public Builder clearPort() {
7084         bitField0_ = (bitField0_ & ~0x00000002);
7085         port_ = 0;
7086         onChanged();
7087         return this;
7088       }
7089
7090       // @@protoc_insertion_point(builder_scope:openxc.ServerConnectSettings)
7091     }
7092
7093     static {
7094       defaultInstance = new ServerConnectSettings(true);
7095       defaultInstance.initFields();
7096     }
7097
7098     // @@protoc_insertion_point(class_scope:openxc.ServerConnectSettings)
7099   }
7100
7101   public interface ModemConfigurationCommandOrBuilder
7102       extends com.google.protobuf.MessageOrBuilder {
7103
7104     // optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;
7105     boolean hasNetworkOperatorSettings();
7106     com.openxc.BinaryMessages.NetworkOperatorSettings getNetworkOperatorSettings();
7107     com.openxc.BinaryMessages.NetworkOperatorSettingsOrBuilder getNetworkOperatorSettingsOrBuilder();
7108
7109     // optional .openxc.NetworkDataSettings networkDataSettings = 2;
7110     boolean hasNetworkDataSettings();
7111     com.openxc.BinaryMessages.NetworkDataSettings getNetworkDataSettings();
7112     com.openxc.BinaryMessages.NetworkDataSettingsOrBuilder getNetworkDataSettingsOrBuilder();
7113
7114     // optional .openxc.ServerConnectSettings serverConnectSettings = 3;
7115     boolean hasServerConnectSettings();
7116     com.openxc.BinaryMessages.ServerConnectSettings getServerConnectSettings();
7117     com.openxc.BinaryMessages.ServerConnectSettingsOrBuilder getServerConnectSettingsOrBuilder();
7118   }
7119   public static final class ModemConfigurationCommand extends
7120       com.google.protobuf.GeneratedMessage
7121       implements ModemConfigurationCommandOrBuilder {
7122     // Use ModemConfigurationCommand.newBuilder() to construct.
7123     private ModemConfigurationCommand(Builder builder) {
7124       super(builder);
7125     }
7126     private ModemConfigurationCommand(boolean noInit) {}
7127
7128     private static final ModemConfigurationCommand defaultInstance;
7129     public static ModemConfigurationCommand getDefaultInstance() {
7130       return defaultInstance;
7131     }
7132
7133     public ModemConfigurationCommand getDefaultInstanceForType() {
7134       return defaultInstance;
7135     }
7136
7137     public static final com.google.protobuf.Descriptors.Descriptor
7138         getDescriptor() {
7139       return com.openxc.BinaryMessages.internal_static_openxc_ModemConfigurationCommand_descriptor;
7140     }
7141
7142     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
7143         internalGetFieldAccessorTable() {
7144       return com.openxc.BinaryMessages.internal_static_openxc_ModemConfigurationCommand_fieldAccessorTable;
7145     }
7146
7147     private int bitField0_;
7148     // optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;
7149     public static final int NETWORKOPERATORSETTINGS_FIELD_NUMBER = 1;
7150     private com.openxc.BinaryMessages.NetworkOperatorSettings networkOperatorSettings_;
7151     public boolean hasNetworkOperatorSettings() {
7152       return ((bitField0_ & 0x00000001) == 0x00000001);
7153     }
7154     public com.openxc.BinaryMessages.NetworkOperatorSettings getNetworkOperatorSettings() {
7155       return networkOperatorSettings_;
7156     }
7157     public com.openxc.BinaryMessages.NetworkOperatorSettingsOrBuilder getNetworkOperatorSettingsOrBuilder() {
7158       return networkOperatorSettings_;
7159     }
7160
7161     // optional .openxc.NetworkDataSettings networkDataSettings = 2;
7162     public static final int NETWORKDATASETTINGS_FIELD_NUMBER = 2;
7163     private com.openxc.BinaryMessages.NetworkDataSettings networkDataSettings_;
7164     public boolean hasNetworkDataSettings() {
7165       return ((bitField0_ & 0x00000002) == 0x00000002);
7166     }
7167     public com.openxc.BinaryMessages.NetworkDataSettings getNetworkDataSettings() {
7168       return networkDataSettings_;
7169     }
7170     public com.openxc.BinaryMessages.NetworkDataSettingsOrBuilder getNetworkDataSettingsOrBuilder() {
7171       return networkDataSettings_;
7172     }
7173
7174     // optional .openxc.ServerConnectSettings serverConnectSettings = 3;
7175     public static final int SERVERCONNECTSETTINGS_FIELD_NUMBER = 3;
7176     private com.openxc.BinaryMessages.ServerConnectSettings serverConnectSettings_;
7177     public boolean hasServerConnectSettings() {
7178       return ((bitField0_ & 0x00000004) == 0x00000004);
7179     }
7180     public com.openxc.BinaryMessages.ServerConnectSettings getServerConnectSettings() {
7181       return serverConnectSettings_;
7182     }
7183     public com.openxc.BinaryMessages.ServerConnectSettingsOrBuilder getServerConnectSettingsOrBuilder() {
7184       return serverConnectSettings_;
7185     }
7186
7187     private void initFields() {
7188       networkOperatorSettings_ = com.openxc.BinaryMessages.NetworkOperatorSettings.getDefaultInstance();
7189       networkDataSettings_ = com.openxc.BinaryMessages.NetworkDataSettings.getDefaultInstance();
7190       serverConnectSettings_ = com.openxc.BinaryMessages.ServerConnectSettings.getDefaultInstance();
7191     }
7192     private byte memoizedIsInitialized = -1;
7193     public final boolean isInitialized() {
7194       byte isInitialized = memoizedIsInitialized;
7195       if (isInitialized != -1) return isInitialized == 1;
7196
7197       memoizedIsInitialized = 1;
7198       return true;
7199     }
7200
7201     public void writeTo(com.google.protobuf.CodedOutputStream output)
7202                         throws java.io.IOException {
7203       getSerializedSize();
7204       if (((bitField0_ & 0x00000001) == 0x00000001)) {
7205         output.writeMessage(1, networkOperatorSettings_);
7206       }
7207       if (((bitField0_ & 0x00000002) == 0x00000002)) {
7208         output.writeMessage(2, networkDataSettings_);
7209       }
7210       if (((bitField0_ & 0x00000004) == 0x00000004)) {
7211         output.writeMessage(3, serverConnectSettings_);
7212       }
7213       getUnknownFields().writeTo(output);
7214     }
7215
7216     private int memoizedSerializedSize = -1;
7217     public int getSerializedSize() {
7218       int size = memoizedSerializedSize;
7219       if (size != -1) return size;
7220
7221       size = 0;
7222       if (((bitField0_ & 0x00000001) == 0x00000001)) {
7223         size += com.google.protobuf.CodedOutputStream
7224           .computeMessageSize(1, networkOperatorSettings_);
7225       }
7226       if (((bitField0_ & 0x00000002) == 0x00000002)) {
7227         size += com.google.protobuf.CodedOutputStream
7228           .computeMessageSize(2, networkDataSettings_);
7229       }
7230       if (((bitField0_ & 0x00000004) == 0x00000004)) {
7231         size += com.google.protobuf.CodedOutputStream
7232           .computeMessageSize(3, serverConnectSettings_);
7233       }
7234       size += getUnknownFields().getSerializedSize();
7235       memoizedSerializedSize = size;
7236       return size;
7237     }
7238
7239     private static final long serialVersionUID = 0L;
7240     @java.lang.Override
7241     protected java.lang.Object writeReplace()
7242         throws java.io.ObjectStreamException {
7243       return super.writeReplace();
7244     }
7245
7246     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseFrom(
7247         com.google.protobuf.ByteString data)
7248         throws com.google.protobuf.InvalidProtocolBufferException {
7249       return newBuilder().mergeFrom(data).buildParsed();
7250     }
7251     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseFrom(
7252         com.google.protobuf.ByteString data,
7253         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7254         throws com.google.protobuf.InvalidProtocolBufferException {
7255       return newBuilder().mergeFrom(data, extensionRegistry)
7256                .buildParsed();
7257     }
7258     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseFrom(byte[] data)
7259         throws com.google.protobuf.InvalidProtocolBufferException {
7260       return newBuilder().mergeFrom(data).buildParsed();
7261     }
7262     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseFrom(
7263         byte[] data,
7264         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7265         throws com.google.protobuf.InvalidProtocolBufferException {
7266       return newBuilder().mergeFrom(data, extensionRegistry)
7267                .buildParsed();
7268     }
7269     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseFrom(java.io.InputStream input)
7270         throws java.io.IOException {
7271       return newBuilder().mergeFrom(input).buildParsed();
7272     }
7273     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseFrom(
7274         java.io.InputStream input,
7275         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7276         throws java.io.IOException {
7277       return newBuilder().mergeFrom(input, extensionRegistry)
7278                .buildParsed();
7279     }
7280     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseDelimitedFrom(java.io.InputStream input)
7281         throws java.io.IOException {
7282       Builder builder = newBuilder();
7283       if (builder.mergeDelimitedFrom(input)) {
7284         return builder.buildParsed();
7285       } else {
7286         return null;
7287       }
7288     }
7289     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseDelimitedFrom(
7290         java.io.InputStream input,
7291         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7292         throws java.io.IOException {
7293       Builder builder = newBuilder();
7294       if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
7295         return builder.buildParsed();
7296       } else {
7297         return null;
7298       }
7299     }
7300     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseFrom(
7301         com.google.protobuf.CodedInputStream input)
7302         throws java.io.IOException {
7303       return newBuilder().mergeFrom(input).buildParsed();
7304     }
7305     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseFrom(
7306         com.google.protobuf.CodedInputStream input,
7307         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7308         throws java.io.IOException {
7309       return newBuilder().mergeFrom(input, extensionRegistry)
7310                .buildParsed();
7311     }
7312
7313     public static Builder newBuilder() { return Builder.create(); }
7314     public Builder newBuilderForType() { return newBuilder(); }
7315     public static Builder newBuilder(com.openxc.BinaryMessages.ModemConfigurationCommand prototype) {
7316       return newBuilder().mergeFrom(prototype);
7317     }
7318     public Builder toBuilder() { return newBuilder(this); }
7319
7320     @java.lang.Override
7321     protected Builder newBuilderForType(
7322         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
7323       Builder builder = new Builder(parent);
7324       return builder;
7325     }
7326     public static final class Builder extends
7327         com.google.protobuf.GeneratedMessage.Builder<Builder>
7328        implements com.openxc.BinaryMessages.ModemConfigurationCommandOrBuilder {
7329       public static final com.google.protobuf.Descriptors.Descriptor
7330           getDescriptor() {
7331         return com.openxc.BinaryMessages.internal_static_openxc_ModemConfigurationCommand_descriptor;
7332       }
7333
7334       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
7335           internalGetFieldAccessorTable() {
7336         return com.openxc.BinaryMessages.internal_static_openxc_ModemConfigurationCommand_fieldAccessorTable;
7337       }
7338
7339       // Construct using com.openxc.BinaryMessages.ModemConfigurationCommand.newBuilder()
7340       private Builder() {
7341         maybeForceBuilderInitialization();
7342       }
7343
7344       private Builder(BuilderParent parent) {
7345         super(parent);
7346         maybeForceBuilderInitialization();
7347       }
7348       private void maybeForceBuilderInitialization() {
7349         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
7350           getNetworkOperatorSettingsFieldBuilder();
7351           getNetworkDataSettingsFieldBuilder();
7352           getServerConnectSettingsFieldBuilder();
7353         }
7354       }
7355       private static Builder create() {
7356         return new Builder();
7357       }
7358
7359       public Builder clear() {
7360         super.clear();
7361         if (networkOperatorSettingsBuilder_ == null) {
7362           networkOperatorSettings_ = com.openxc.BinaryMessages.NetworkOperatorSettings.getDefaultInstance();
7363         } else {
7364           networkOperatorSettingsBuilder_.clear();
7365         }
7366         bitField0_ = (bitField0_ & ~0x00000001);
7367         if (networkDataSettingsBuilder_ == null) {
7368           networkDataSettings_ = com.openxc.BinaryMessages.NetworkDataSettings.getDefaultInstance();
7369         } else {
7370           networkDataSettingsBuilder_.clear();
7371         }
7372         bitField0_ = (bitField0_ & ~0x00000002);
7373         if (serverConnectSettingsBuilder_ == null) {
7374           serverConnectSettings_ = com.openxc.BinaryMessages.ServerConnectSettings.getDefaultInstance();
7375         } else {
7376           serverConnectSettingsBuilder_.clear();
7377         }
7378         bitField0_ = (bitField0_ & ~0x00000004);
7379         return this;
7380       }
7381
7382       public Builder clone() {
7383         return create().mergeFrom(buildPartial());
7384       }
7385
7386       public com.google.protobuf.Descriptors.Descriptor
7387           getDescriptorForType() {
7388         return com.openxc.BinaryMessages.ModemConfigurationCommand.getDescriptor();
7389       }
7390
7391       public com.openxc.BinaryMessages.ModemConfigurationCommand getDefaultInstanceForType() {
7392         return com.openxc.BinaryMessages.ModemConfigurationCommand.getDefaultInstance();
7393       }
7394
7395       public com.openxc.BinaryMessages.ModemConfigurationCommand build() {
7396         com.openxc.BinaryMessages.ModemConfigurationCommand result = buildPartial();
7397         if (!result.isInitialized()) {
7398           throw newUninitializedMessageException(result);
7399         }
7400         return result;
7401       }
7402
7403       private com.openxc.BinaryMessages.ModemConfigurationCommand buildParsed()
7404           throws com.google.protobuf.InvalidProtocolBufferException {
7405         com.openxc.BinaryMessages.ModemConfigurationCommand result = buildPartial();
7406         if (!result.isInitialized()) {
7407           throw newUninitializedMessageException(
7408             result).asInvalidProtocolBufferException();
7409         }
7410         return result;
7411       }
7412
7413       public com.openxc.BinaryMessages.ModemConfigurationCommand buildPartial() {
7414         com.openxc.BinaryMessages.ModemConfigurationCommand result = new com.openxc.BinaryMessages.ModemConfigurationCommand(this);
7415         int from_bitField0_ = bitField0_;
7416         int to_bitField0_ = 0;
7417         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
7418           to_bitField0_ |= 0x00000001;
7419         }
7420         if (networkOperatorSettingsBuilder_ == null) {
7421           result.networkOperatorSettings_ = networkOperatorSettings_;
7422         } else {
7423           result.networkOperatorSettings_ = networkOperatorSettingsBuilder_.build();
7424         }
7425         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
7426           to_bitField0_ |= 0x00000002;
7427         }
7428         if (networkDataSettingsBuilder_ == null) {
7429           result.networkDataSettings_ = networkDataSettings_;
7430         } else {
7431           result.networkDataSettings_ = networkDataSettingsBuilder_.build();
7432         }
7433         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
7434           to_bitField0_ |= 0x00000004;
7435         }
7436         if (serverConnectSettingsBuilder_ == null) {
7437           result.serverConnectSettings_ = serverConnectSettings_;
7438         } else {
7439           result.serverConnectSettings_ = serverConnectSettingsBuilder_.build();
7440         }
7441         result.bitField0_ = to_bitField0_;
7442         onBuilt();
7443         return result;
7444       }
7445
7446       public Builder mergeFrom(com.google.protobuf.Message other) {
7447         if (other instanceof com.openxc.BinaryMessages.ModemConfigurationCommand) {
7448           return mergeFrom((com.openxc.BinaryMessages.ModemConfigurationCommand)other);
7449         } else {
7450           super.mergeFrom(other);
7451           return this;
7452         }
7453       }
7454
7455       public Builder mergeFrom(com.openxc.BinaryMessages.ModemConfigurationCommand other) {
7456         if (other == com.openxc.BinaryMessages.ModemConfigurationCommand.getDefaultInstance()) return this;
7457         if (other.hasNetworkOperatorSettings()) {
7458           mergeNetworkOperatorSettings(other.getNetworkOperatorSettings());
7459         }
7460         if (other.hasNetworkDataSettings()) {
7461           mergeNetworkDataSettings(other.getNetworkDataSettings());
7462         }
7463         if (other.hasServerConnectSettings()) {
7464           mergeServerConnectSettings(other.getServerConnectSettings());
7465         }
7466         this.mergeUnknownFields(other.getUnknownFields());
7467         return this;
7468       }
7469
7470       public final boolean isInitialized() {
7471         return true;
7472       }
7473
7474       public Builder mergeFrom(
7475           com.google.protobuf.CodedInputStream input,
7476           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7477           throws java.io.IOException {
7478         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
7479           com.google.protobuf.UnknownFieldSet.newBuilder(
7480             this.getUnknownFields());
7481         while (true) {
7482           int tag = input.readTag();
7483           switch (tag) {
7484             case 0:
7485               this.setUnknownFields(unknownFields.build());
7486               onChanged();
7487               return this;
7488             default: {
7489               if (!parseUnknownField(input, unknownFields,
7490                                      extensionRegistry, tag)) {
7491                 this.setUnknownFields(unknownFields.build());
7492                 onChanged();
7493                 return this;
7494               }
7495               break;
7496             }
7497             case 10: {
7498               com.openxc.BinaryMessages.NetworkOperatorSettings.Builder subBuilder = com.openxc.BinaryMessages.NetworkOperatorSettings.newBuilder();
7499               if (hasNetworkOperatorSettings()) {
7500                 subBuilder.mergeFrom(getNetworkOperatorSettings());
7501               }
7502               input.readMessage(subBuilder, extensionRegistry);
7503               setNetworkOperatorSettings(subBuilder.buildPartial());
7504               break;
7505             }
7506             case 18: {
7507               com.openxc.BinaryMessages.NetworkDataSettings.Builder subBuilder = com.openxc.BinaryMessages.NetworkDataSettings.newBuilder();
7508               if (hasNetworkDataSettings()) {
7509                 subBuilder.mergeFrom(getNetworkDataSettings());
7510               }
7511               input.readMessage(subBuilder, extensionRegistry);
7512               setNetworkDataSettings(subBuilder.buildPartial());
7513               break;
7514             }
7515             case 26: {
7516               com.openxc.BinaryMessages.ServerConnectSettings.Builder subBuilder = com.openxc.BinaryMessages.ServerConnectSettings.newBuilder();
7517               if (hasServerConnectSettings()) {
7518                 subBuilder.mergeFrom(getServerConnectSettings());
7519               }
7520               input.readMessage(subBuilder, extensionRegistry);
7521               setServerConnectSettings(subBuilder.buildPartial());
7522               break;
7523             }
7524           }
7525         }
7526       }
7527
7528       private int bitField0_;
7529
7530       // optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;
7531       private com.openxc.BinaryMessages.NetworkOperatorSettings networkOperatorSettings_ = com.openxc.BinaryMessages.NetworkOperatorSettings.getDefaultInstance();
7532       private com.google.protobuf.SingleFieldBuilder<
7533           com.openxc.BinaryMessages.NetworkOperatorSettings, com.openxc.BinaryMessages.NetworkOperatorSettings.Builder, com.openxc.BinaryMessages.NetworkOperatorSettingsOrBuilder> networkOperatorSettingsBuilder_;
7534       public boolean hasNetworkOperatorSettings() {
7535         return ((bitField0_ & 0x00000001) == 0x00000001);
7536       }
7537       public com.openxc.BinaryMessages.NetworkOperatorSettings getNetworkOperatorSettings() {
7538         if (networkOperatorSettingsBuilder_ == null) {
7539           return networkOperatorSettings_;
7540         } else {
7541           return networkOperatorSettingsBuilder_.getMessage();
7542         }
7543       }
7544       public Builder setNetworkOperatorSettings(com.openxc.BinaryMessages.NetworkOperatorSettings value) {
7545         if (networkOperatorSettingsBuilder_ == null) {
7546           if (value == null) {
7547             throw new NullPointerException();
7548           }
7549           networkOperatorSettings_ = value;
7550           onChanged();
7551         } else {
7552           networkOperatorSettingsBuilder_.setMessage(value);
7553         }
7554         bitField0_ |= 0x00000001;
7555         return this;
7556       }
7557       public Builder setNetworkOperatorSettings(
7558           com.openxc.BinaryMessages.NetworkOperatorSettings.Builder builderForValue) {
7559         if (networkOperatorSettingsBuilder_ == null) {
7560           networkOperatorSettings_ = builderForValue.build();
7561           onChanged();
7562         } else {
7563           networkOperatorSettingsBuilder_.setMessage(builderForValue.build());
7564         }
7565         bitField0_ |= 0x00000001;
7566         return this;
7567       }
7568       public Builder mergeNetworkOperatorSettings(com.openxc.BinaryMessages.NetworkOperatorSettings value) {
7569         if (networkOperatorSettingsBuilder_ == null) {
7570           if (((bitField0_ & 0x00000001) == 0x00000001) &&
7571               networkOperatorSettings_ != com.openxc.BinaryMessages.NetworkOperatorSettings.getDefaultInstance()) {
7572             networkOperatorSettings_ =
7573               com.openxc.BinaryMessages.NetworkOperatorSettings.newBuilder(networkOperatorSettings_).mergeFrom(value).buildPartial();
7574           } else {
7575             networkOperatorSettings_ = value;
7576           }
7577           onChanged();
7578         } else {
7579           networkOperatorSettingsBuilder_.mergeFrom(value);
7580         }
7581         bitField0_ |= 0x00000001;
7582         return this;
7583       }
7584       public Builder clearNetworkOperatorSettings() {
7585         if (networkOperatorSettingsBuilder_ == null) {
7586           networkOperatorSettings_ = com.openxc.BinaryMessages.NetworkOperatorSettings.getDefaultInstance();
7587           onChanged();
7588         } else {
7589           networkOperatorSettingsBuilder_.clear();
7590         }
7591         bitField0_ = (bitField0_ & ~0x00000001);
7592         return this;
7593       }
7594       public com.openxc.BinaryMessages.NetworkOperatorSettings.Builder getNetworkOperatorSettingsBuilder() {
7595         bitField0_ |= 0x00000001;
7596         onChanged();
7597         return getNetworkOperatorSettingsFieldBuilder().getBuilder();
7598       }
7599       public com.openxc.BinaryMessages.NetworkOperatorSettingsOrBuilder getNetworkOperatorSettingsOrBuilder() {
7600         if (networkOperatorSettingsBuilder_ != null) {
7601           return networkOperatorSettingsBuilder_.getMessageOrBuilder();
7602         } else {
7603           return networkOperatorSettings_;
7604         }
7605       }
7606       private com.google.protobuf.SingleFieldBuilder<
7607           com.openxc.BinaryMessages.NetworkOperatorSettings, com.openxc.BinaryMessages.NetworkOperatorSettings.Builder, com.openxc.BinaryMessages.NetworkOperatorSettingsOrBuilder>
7608           getNetworkOperatorSettingsFieldBuilder() {
7609         if (networkOperatorSettingsBuilder_ == null) {
7610           networkOperatorSettingsBuilder_ = new com.google.protobuf.SingleFieldBuilder<
7611               com.openxc.BinaryMessages.NetworkOperatorSettings, com.openxc.BinaryMessages.NetworkOperatorSettings.Builder, com.openxc.BinaryMessages.NetworkOperatorSettingsOrBuilder>(
7612                   networkOperatorSettings_,
7613                   getParentForChildren(),
7614                   isClean());
7615           networkOperatorSettings_ = null;
7616         }
7617         return networkOperatorSettingsBuilder_;
7618       }
7619
7620       // optional .openxc.NetworkDataSettings networkDataSettings = 2;
7621       private com.openxc.BinaryMessages.NetworkDataSettings networkDataSettings_ = com.openxc.BinaryMessages.NetworkDataSettings.getDefaultInstance();
7622       private com.google.protobuf.SingleFieldBuilder<
7623           com.openxc.BinaryMessages.NetworkDataSettings, com.openxc.BinaryMessages.NetworkDataSettings.Builder, com.openxc.BinaryMessages.NetworkDataSettingsOrBuilder> networkDataSettingsBuilder_;
7624       public boolean hasNetworkDataSettings() {
7625         return ((bitField0_ & 0x00000002) == 0x00000002);
7626       }
7627       public com.openxc.BinaryMessages.NetworkDataSettings getNetworkDataSettings() {
7628         if (networkDataSettingsBuilder_ == null) {
7629           return networkDataSettings_;
7630         } else {
7631           return networkDataSettingsBuilder_.getMessage();
7632         }
7633       }
7634       public Builder setNetworkDataSettings(com.openxc.BinaryMessages.NetworkDataSettings value) {
7635         if (networkDataSettingsBuilder_ == null) {
7636           if (value == null) {
7637             throw new NullPointerException();
7638           }
7639           networkDataSettings_ = value;
7640           onChanged();
7641         } else {
7642           networkDataSettingsBuilder_.setMessage(value);
7643         }
7644         bitField0_ |= 0x00000002;
7645         return this;
7646       }
7647       public Builder setNetworkDataSettings(
7648           com.openxc.BinaryMessages.NetworkDataSettings.Builder builderForValue) {
7649         if (networkDataSettingsBuilder_ == null) {
7650           networkDataSettings_ = builderForValue.build();
7651           onChanged();
7652         } else {
7653           networkDataSettingsBuilder_.setMessage(builderForValue.build());
7654         }
7655         bitField0_ |= 0x00000002;
7656         return this;
7657       }
7658       public Builder mergeNetworkDataSettings(com.openxc.BinaryMessages.NetworkDataSettings value) {
7659         if (networkDataSettingsBuilder_ == null) {
7660           if (((bitField0_ & 0x00000002) == 0x00000002) &&
7661               networkDataSettings_ != com.openxc.BinaryMessages.NetworkDataSettings.getDefaultInstance()) {
7662             networkDataSettings_ =
7663               com.openxc.BinaryMessages.NetworkDataSettings.newBuilder(networkDataSettings_).mergeFrom(value).buildPartial();
7664           } else {
7665             networkDataSettings_ = value;
7666           }
7667           onChanged();
7668         } else {
7669           networkDataSettingsBuilder_.mergeFrom(value);
7670         }
7671         bitField0_ |= 0x00000002;
7672         return this;
7673       }
7674       public Builder clearNetworkDataSettings() {
7675         if (networkDataSettingsBuilder_ == null) {
7676           networkDataSettings_ = com.openxc.BinaryMessages.NetworkDataSettings.getDefaultInstance();
7677           onChanged();
7678         } else {
7679           networkDataSettingsBuilder_.clear();
7680         }
7681         bitField0_ = (bitField0_ & ~0x00000002);
7682         return this;
7683       }
7684       public com.openxc.BinaryMessages.NetworkDataSettings.Builder getNetworkDataSettingsBuilder() {
7685         bitField0_ |= 0x00000002;
7686         onChanged();
7687         return getNetworkDataSettingsFieldBuilder().getBuilder();
7688       }
7689       public com.openxc.BinaryMessages.NetworkDataSettingsOrBuilder getNetworkDataSettingsOrBuilder() {
7690         if (networkDataSettingsBuilder_ != null) {
7691           return networkDataSettingsBuilder_.getMessageOrBuilder();
7692         } else {
7693           return networkDataSettings_;
7694         }
7695       }
7696       private com.google.protobuf.SingleFieldBuilder<
7697           com.openxc.BinaryMessages.NetworkDataSettings, com.openxc.BinaryMessages.NetworkDataSettings.Builder, com.openxc.BinaryMessages.NetworkDataSettingsOrBuilder>
7698           getNetworkDataSettingsFieldBuilder() {
7699         if (networkDataSettingsBuilder_ == null) {
7700           networkDataSettingsBuilder_ = new com.google.protobuf.SingleFieldBuilder<
7701               com.openxc.BinaryMessages.NetworkDataSettings, com.openxc.BinaryMessages.NetworkDataSettings.Builder, com.openxc.BinaryMessages.NetworkDataSettingsOrBuilder>(
7702                   networkDataSettings_,
7703                   getParentForChildren(),
7704                   isClean());
7705           networkDataSettings_ = null;
7706         }
7707         return networkDataSettingsBuilder_;
7708       }
7709
7710       // optional .openxc.ServerConnectSettings serverConnectSettings = 3;
7711       private com.openxc.BinaryMessages.ServerConnectSettings serverConnectSettings_ = com.openxc.BinaryMessages.ServerConnectSettings.getDefaultInstance();
7712       private com.google.protobuf.SingleFieldBuilder<
7713           com.openxc.BinaryMessages.ServerConnectSettings, com.openxc.BinaryMessages.ServerConnectSettings.Builder, com.openxc.BinaryMessages.ServerConnectSettingsOrBuilder> serverConnectSettingsBuilder_;
7714       public boolean hasServerConnectSettings() {
7715         return ((bitField0_ & 0x00000004) == 0x00000004);
7716       }
7717       public com.openxc.BinaryMessages.ServerConnectSettings getServerConnectSettings() {
7718         if (serverConnectSettingsBuilder_ == null) {
7719           return serverConnectSettings_;
7720         } else {
7721           return serverConnectSettingsBuilder_.getMessage();
7722         }
7723       }
7724       public Builder setServerConnectSettings(com.openxc.BinaryMessages.ServerConnectSettings value) {
7725         if (serverConnectSettingsBuilder_ == null) {
7726           if (value == null) {
7727             throw new NullPointerException();
7728           }
7729           serverConnectSettings_ = value;
7730           onChanged();
7731         } else {
7732           serverConnectSettingsBuilder_.setMessage(value);
7733         }
7734         bitField0_ |= 0x00000004;
7735         return this;
7736       }
7737       public Builder setServerConnectSettings(
7738           com.openxc.BinaryMessages.ServerConnectSettings.Builder builderForValue) {
7739         if (serverConnectSettingsBuilder_ == null) {
7740           serverConnectSettings_ = builderForValue.build();
7741           onChanged();
7742         } else {
7743           serverConnectSettingsBuilder_.setMessage(builderForValue.build());
7744         }
7745         bitField0_ |= 0x00000004;
7746         return this;
7747       }
7748       public Builder mergeServerConnectSettings(com.openxc.BinaryMessages.ServerConnectSettings value) {
7749         if (serverConnectSettingsBuilder_ == null) {
7750           if (((bitField0_ & 0x00000004) == 0x00000004) &&
7751               serverConnectSettings_ != com.openxc.BinaryMessages.ServerConnectSettings.getDefaultInstance()) {
7752             serverConnectSettings_ =
7753               com.openxc.BinaryMessages.ServerConnectSettings.newBuilder(serverConnectSettings_).mergeFrom(value).buildPartial();
7754           } else {
7755             serverConnectSettings_ = value;
7756           }
7757           onChanged();
7758         } else {
7759           serverConnectSettingsBuilder_.mergeFrom(value);
7760         }
7761         bitField0_ |= 0x00000004;
7762         return this;
7763       }
7764       public Builder clearServerConnectSettings() {
7765         if (serverConnectSettingsBuilder_ == null) {
7766           serverConnectSettings_ = com.openxc.BinaryMessages.ServerConnectSettings.getDefaultInstance();
7767           onChanged();
7768         } else {
7769           serverConnectSettingsBuilder_.clear();
7770         }
7771         bitField0_ = (bitField0_ & ~0x00000004);
7772         return this;
7773       }
7774       public com.openxc.BinaryMessages.ServerConnectSettings.Builder getServerConnectSettingsBuilder() {
7775         bitField0_ |= 0x00000004;
7776         onChanged();
7777         return getServerConnectSettingsFieldBuilder().getBuilder();
7778       }
7779       public com.openxc.BinaryMessages.ServerConnectSettingsOrBuilder getServerConnectSettingsOrBuilder() {
7780         if (serverConnectSettingsBuilder_ != null) {
7781           return serverConnectSettingsBuilder_.getMessageOrBuilder();
7782         } else {
7783           return serverConnectSettings_;
7784         }
7785       }
7786       private com.google.protobuf.SingleFieldBuilder<
7787           com.openxc.BinaryMessages.ServerConnectSettings, com.openxc.BinaryMessages.ServerConnectSettings.Builder, com.openxc.BinaryMessages.ServerConnectSettingsOrBuilder>
7788           getServerConnectSettingsFieldBuilder() {
7789         if (serverConnectSettingsBuilder_ == null) {
7790           serverConnectSettingsBuilder_ = new com.google.protobuf.SingleFieldBuilder<
7791               com.openxc.BinaryMessages.ServerConnectSettings, com.openxc.BinaryMessages.ServerConnectSettings.Builder, com.openxc.BinaryMessages.ServerConnectSettingsOrBuilder>(
7792                   serverConnectSettings_,
7793                   getParentForChildren(),
7794                   isClean());
7795           serverConnectSettings_ = null;
7796         }
7797         return serverConnectSettingsBuilder_;
7798       }
7799
7800       // @@protoc_insertion_point(builder_scope:openxc.ModemConfigurationCommand)
7801     }
7802
7803     static {
7804       defaultInstance = new ModemConfigurationCommand(true);
7805       defaultInstance.initFields();
7806     }
7807
7808     // @@protoc_insertion_point(class_scope:openxc.ModemConfigurationCommand)
7809   }
7810
7811   public interface CommandResponseOrBuilder
7812       extends com.google.protobuf.MessageOrBuilder {
7813
7814     // optional .openxc.ControlCommand.Type type = 1;
7815     boolean hasType();
7816     com.openxc.BinaryMessages.ControlCommand.Type getType();
7817
7818     // optional string message = 2;
7819     boolean hasMessage();
7820     String getMessage();
7821
7822     // optional bool status = 3;
7823     boolean hasStatus();
7824     boolean getStatus();
7825   }
7826   public static final class CommandResponse extends
7827       com.google.protobuf.GeneratedMessage
7828       implements CommandResponseOrBuilder {
7829     // Use CommandResponse.newBuilder() to construct.
7830     private CommandResponse(Builder builder) {
7831       super(builder);
7832     }
7833     private CommandResponse(boolean noInit) {}
7834
7835     private static final CommandResponse defaultInstance;
7836     public static CommandResponse getDefaultInstance() {
7837       return defaultInstance;
7838     }
7839
7840     public CommandResponse getDefaultInstanceForType() {
7841       return defaultInstance;
7842     }
7843
7844     public static final com.google.protobuf.Descriptors.Descriptor
7845         getDescriptor() {
7846       return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
7847     }
7848
7849     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
7850         internalGetFieldAccessorTable() {
7851       return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_fieldAccessorTable;
7852     }
7853
7854     private int bitField0_;
7855     // optional .openxc.ControlCommand.Type type = 1;
7856     public static final int TYPE_FIELD_NUMBER = 1;
7857     private com.openxc.BinaryMessages.ControlCommand.Type type_;
7858     public boolean hasType() {
7859       return ((bitField0_ & 0x00000001) == 0x00000001);
7860     }
7861     public com.openxc.BinaryMessages.ControlCommand.Type getType() {
7862       return type_;
7863     }
7864
7865     // optional string message = 2;
7866     public static final int MESSAGE_FIELD_NUMBER = 2;
7867     private java.lang.Object message_;
7868     public boolean hasMessage() {
7869       return ((bitField0_ & 0x00000002) == 0x00000002);
7870     }
7871     public String getMessage() {
7872       java.lang.Object ref = message_;
7873       if (ref instanceof String) {
7874         return (String) ref;
7875       } else {
7876         com.google.protobuf.ByteString bs =
7877             (com.google.protobuf.ByteString) ref;
7878         String s = bs.toStringUtf8();
7879         if (com.google.protobuf.Internal.isValidUtf8(bs)) {
7880           message_ = s;
7881         }
7882         return s;
7883       }
7884     }
7885     private com.google.protobuf.ByteString getMessageBytes() {
7886       java.lang.Object ref = message_;
7887       if (ref instanceof String) {
7888         com.google.protobuf.ByteString b =
7889             com.google.protobuf.ByteString.copyFromUtf8((String) ref);
7890         message_ = b;
7891         return b;
7892       } else {
7893         return (com.google.protobuf.ByteString) ref;
7894       }
7895     }
7896
7897     // optional bool status = 3;
7898     public static final int STATUS_FIELD_NUMBER = 3;
7899     private boolean status_;
7900     public boolean hasStatus() {
7901       return ((bitField0_ & 0x00000004) == 0x00000004);
7902     }
7903     public boolean getStatus() {
7904       return status_;
7905     }
7906
7907     private void initFields() {
7908       type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
7909       message_ = "";
7910       status_ = false;
7911     }
7912     private byte memoizedIsInitialized = -1;
7913     public final boolean isInitialized() {
7914       byte isInitialized = memoizedIsInitialized;
7915       if (isInitialized != -1) return isInitialized == 1;
7916
7917       memoizedIsInitialized = 1;
7918       return true;
7919     }
7920
7921     public void writeTo(com.google.protobuf.CodedOutputStream output)
7922                         throws java.io.IOException {
7923       getSerializedSize();
7924       if (((bitField0_ & 0x00000001) == 0x00000001)) {
7925         output.writeEnum(1, type_.getNumber());
7926       }
7927       if (((bitField0_ & 0x00000002) == 0x00000002)) {
7928         output.writeBytes(2, getMessageBytes());
7929       }
7930       if (((bitField0_ & 0x00000004) == 0x00000004)) {
7931         output.writeBool(3, status_);
7932       }
7933       getUnknownFields().writeTo(output);
7934     }
7935
7936     private int memoizedSerializedSize = -1;
7937     public int getSerializedSize() {
7938       int size = memoizedSerializedSize;
7939       if (size != -1) return size;
7940
7941       size = 0;
7942       if (((bitField0_ & 0x00000001) == 0x00000001)) {
7943         size += com.google.protobuf.CodedOutputStream
7944           .computeEnumSize(1, type_.getNumber());
7945       }
7946       if (((bitField0_ & 0x00000002) == 0x00000002)) {
7947         size += com.google.protobuf.CodedOutputStream
7948           .computeBytesSize(2, getMessageBytes());
7949       }
7950       if (((bitField0_ & 0x00000004) == 0x00000004)) {
7951         size += com.google.protobuf.CodedOutputStream
7952           .computeBoolSize(3, status_);
7953       }
7954       size += getUnknownFields().getSerializedSize();
7955       memoizedSerializedSize = size;
7956       return size;
7957     }
7958
7959     private static final long serialVersionUID = 0L;
7960     @java.lang.Override
7961     protected java.lang.Object writeReplace()
7962         throws java.io.ObjectStreamException {
7963       return super.writeReplace();
7964     }
7965
7966     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
7967         com.google.protobuf.ByteString data)
7968         throws com.google.protobuf.InvalidProtocolBufferException {
7969       return newBuilder().mergeFrom(data).buildParsed();
7970     }
7971     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
7972         com.google.protobuf.ByteString data,
7973         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7974         throws com.google.protobuf.InvalidProtocolBufferException {
7975       return newBuilder().mergeFrom(data, extensionRegistry)
7976                .buildParsed();
7977     }
7978     public static com.openxc.BinaryMessages.CommandResponse parseFrom(byte[] data)
7979         throws com.google.protobuf.InvalidProtocolBufferException {
7980       return newBuilder().mergeFrom(data).buildParsed();
7981     }
7982     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
7983         byte[] data,
7984         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7985         throws com.google.protobuf.InvalidProtocolBufferException {
7986       return newBuilder().mergeFrom(data, extensionRegistry)
7987                .buildParsed();
7988     }
7989     public static com.openxc.BinaryMessages.CommandResponse parseFrom(java.io.InputStream input)
7990         throws java.io.IOException {
7991       return newBuilder().mergeFrom(input).buildParsed();
7992     }
7993     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
7994         java.io.InputStream input,
7995         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7996         throws java.io.IOException {
7997       return newBuilder().mergeFrom(input, extensionRegistry)
7998                .buildParsed();
7999     }
8000     public static com.openxc.BinaryMessages.CommandResponse parseDelimitedFrom(java.io.InputStream input)
8001         throws java.io.IOException {
8002       Builder builder = newBuilder();
8003       if (builder.mergeDelimitedFrom(input)) {
8004         return builder.buildParsed();
8005       } else {
8006         return null;
8007       }
8008     }
8009     public static com.openxc.BinaryMessages.CommandResponse parseDelimitedFrom(
8010         java.io.InputStream input,
8011         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8012         throws java.io.IOException {
8013       Builder builder = newBuilder();
8014       if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
8015         return builder.buildParsed();
8016       } else {
8017         return null;
8018       }
8019     }
8020     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
8021         com.google.protobuf.CodedInputStream input)
8022         throws java.io.IOException {
8023       return newBuilder().mergeFrom(input).buildParsed();
8024     }
8025     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
8026         com.google.protobuf.CodedInputStream input,
8027         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8028         throws java.io.IOException {
8029       return newBuilder().mergeFrom(input, extensionRegistry)
8030                .buildParsed();
8031     }
8032
8033     public static Builder newBuilder() { return Builder.create(); }
8034     public Builder newBuilderForType() { return newBuilder(); }
8035     public static Builder newBuilder(com.openxc.BinaryMessages.CommandResponse prototype) {
8036       return newBuilder().mergeFrom(prototype);
8037     }
8038     public Builder toBuilder() { return newBuilder(this); }
8039
8040     @java.lang.Override
8041     protected Builder newBuilderForType(
8042         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
8043       Builder builder = new Builder(parent);
8044       return builder;
8045     }
8046     public static final class Builder extends
8047         com.google.protobuf.GeneratedMessage.Builder<Builder>
8048        implements com.openxc.BinaryMessages.CommandResponseOrBuilder {
8049       public static final com.google.protobuf.Descriptors.Descriptor
8050           getDescriptor() {
8051         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
8052       }
8053
8054       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
8055           internalGetFieldAccessorTable() {
8056         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_fieldAccessorTable;
8057       }
8058
8059       // Construct using com.openxc.BinaryMessages.CommandResponse.newBuilder()
8060       private Builder() {
8061         maybeForceBuilderInitialization();
8062       }
8063
8064       private Builder(BuilderParent parent) {
8065         super(parent);
8066         maybeForceBuilderInitialization();
8067       }
8068       private void maybeForceBuilderInitialization() {
8069         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
8070         }
8071       }
8072       private static Builder create() {
8073         return new Builder();
8074       }
8075
8076       public Builder clear() {
8077         super.clear();
8078         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
8079         bitField0_ = (bitField0_ & ~0x00000001);
8080         message_ = "";
8081         bitField0_ = (bitField0_ & ~0x00000002);
8082         status_ = false;
8083         bitField0_ = (bitField0_ & ~0x00000004);
8084         return this;
8085       }
8086
8087       public Builder clone() {
8088         return create().mergeFrom(buildPartial());
8089       }
8090
8091       public com.google.protobuf.Descriptors.Descriptor
8092           getDescriptorForType() {
8093         return com.openxc.BinaryMessages.CommandResponse.getDescriptor();
8094       }
8095
8096       public com.openxc.BinaryMessages.CommandResponse getDefaultInstanceForType() {
8097         return com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
8098       }
8099
8100       public com.openxc.BinaryMessages.CommandResponse build() {
8101         com.openxc.BinaryMessages.CommandResponse result = buildPartial();
8102         if (!result.isInitialized()) {
8103           throw newUninitializedMessageException(result);
8104         }
8105         return result;
8106       }
8107
8108       private com.openxc.BinaryMessages.CommandResponse buildParsed()
8109           throws com.google.protobuf.InvalidProtocolBufferException {
8110         com.openxc.BinaryMessages.CommandResponse result = buildPartial();
8111         if (!result.isInitialized()) {
8112           throw newUninitializedMessageException(
8113             result).asInvalidProtocolBufferException();
8114         }
8115         return result;
8116       }
8117
8118       public com.openxc.BinaryMessages.CommandResponse buildPartial() {
8119         com.openxc.BinaryMessages.CommandResponse result = new com.openxc.BinaryMessages.CommandResponse(this);
8120         int from_bitField0_ = bitField0_;
8121         int to_bitField0_ = 0;
8122         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
8123           to_bitField0_ |= 0x00000001;
8124         }
8125         result.type_ = type_;
8126         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
8127           to_bitField0_ |= 0x00000002;
8128         }
8129         result.message_ = message_;
8130         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
8131           to_bitField0_ |= 0x00000004;
8132         }
8133         result.status_ = status_;
8134         result.bitField0_ = to_bitField0_;
8135         onBuilt();
8136         return result;
8137       }
8138
8139       public Builder mergeFrom(com.google.protobuf.Message other) {
8140         if (other instanceof com.openxc.BinaryMessages.CommandResponse) {
8141           return mergeFrom((com.openxc.BinaryMessages.CommandResponse)other);
8142         } else {
8143           super.mergeFrom(other);
8144           return this;
8145         }
8146       }
8147
8148       public Builder mergeFrom(com.openxc.BinaryMessages.CommandResponse other) {
8149         if (other == com.openxc.BinaryMessages.CommandResponse.getDefaultInstance()) return this;
8150         if (other.hasType()) {
8151           setType(other.getType());
8152         }
8153         if (other.hasMessage()) {
8154           setMessage(other.getMessage());
8155         }
8156         if (other.hasStatus()) {
8157           setStatus(other.getStatus());
8158         }
8159         this.mergeUnknownFields(other.getUnknownFields());
8160         return this;
8161       }
8162
8163       public final boolean isInitialized() {
8164         return true;
8165       }
8166
8167       public Builder mergeFrom(
8168           com.google.protobuf.CodedInputStream input,
8169           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8170           throws java.io.IOException {
8171         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
8172           com.google.protobuf.UnknownFieldSet.newBuilder(
8173             this.getUnknownFields());
8174         while (true) {
8175           int tag = input.readTag();
8176           switch (tag) {
8177             case 0:
8178               this.setUnknownFields(unknownFields.build());
8179               onChanged();
8180               return this;
8181             default: {
8182               if (!parseUnknownField(input, unknownFields,
8183                                      extensionRegistry, tag)) {
8184                 this.setUnknownFields(unknownFields.build());
8185                 onChanged();
8186                 return this;
8187               }
8188               break;
8189             }
8190             case 8: {
8191               int rawValue = input.readEnum();
8192               com.openxc.BinaryMessages.ControlCommand.Type value = com.openxc.BinaryMessages.ControlCommand.Type.valueOf(rawValue);
8193               if (value == null) {
8194                 unknownFields.mergeVarintField(1, rawValue);
8195               } else {
8196                 bitField0_ |= 0x00000001;
8197                 type_ = value;
8198               }
8199               break;
8200             }
8201             case 18: {
8202               bitField0_ |= 0x00000002;
8203               message_ = input.readBytes();
8204               break;
8205             }
8206             case 24: {
8207               bitField0_ |= 0x00000004;
8208               status_ = input.readBool();
8209               break;
8210             }
8211           }
8212         }
8213       }
8214
8215       private int bitField0_;
8216
8217       // optional .openxc.ControlCommand.Type type = 1;
8218       private com.openxc.BinaryMessages.ControlCommand.Type type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
8219       public boolean hasType() {
8220         return ((bitField0_ & 0x00000001) == 0x00000001);
8221       }
8222       public com.openxc.BinaryMessages.ControlCommand.Type getType() {
8223         return type_;
8224       }
8225       public Builder setType(com.openxc.BinaryMessages.ControlCommand.Type value) {
8226         if (value == null) {
8227           throw new NullPointerException();
8228         }
8229         bitField0_ |= 0x00000001;
8230         type_ = value;
8231         onChanged();
8232         return this;
8233       }
8234       public Builder clearType() {
8235         bitField0_ = (bitField0_ & ~0x00000001);
8236         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
8237         onChanged();
8238         return this;
8239       }
8240
8241       // optional string message = 2;
8242       private java.lang.Object message_ = "";
8243       public boolean hasMessage() {
8244         return ((bitField0_ & 0x00000002) == 0x00000002);
8245       }
8246       public String getMessage() {
8247         java.lang.Object ref = message_;
8248         if (!(ref instanceof String)) {
8249           String s = ((com.google.protobuf.ByteString) ref).toStringUtf8();
8250           message_ = s;
8251           return s;
8252         } else {
8253           return (String) ref;
8254         }
8255       }
8256       public Builder setMessage(String value) {
8257         if (value == null) {
8258     throw new NullPointerException();
8259   }
8260   bitField0_ |= 0x00000002;
8261         message_ = value;
8262         onChanged();
8263         return this;
8264       }
8265       public Builder clearMessage() {
8266         bitField0_ = (bitField0_ & ~0x00000002);
8267         message_ = getDefaultInstance().getMessage();
8268         onChanged();
8269         return this;
8270       }
8271       void setMessage(com.google.protobuf.ByteString value) {
8272         bitField0_ |= 0x00000002;
8273         message_ = value;
8274         onChanged();
8275       }
8276
8277       // optional bool status = 3;
8278       private boolean status_ ;
8279       public boolean hasStatus() {
8280         return ((bitField0_ & 0x00000004) == 0x00000004);
8281       }
8282       public boolean getStatus() {
8283         return status_;
8284       }
8285       public Builder setStatus(boolean value) {
8286         bitField0_ |= 0x00000004;
8287         status_ = value;
8288         onChanged();
8289         return this;
8290       }
8291       public Builder clearStatus() {
8292         bitField0_ = (bitField0_ & ~0x00000004);
8293         status_ = false;
8294         onChanged();
8295         return this;
8296       }
8297
8298       // @@protoc_insertion_point(builder_scope:openxc.CommandResponse)
8299     }
8300
8301     static {
8302       defaultInstance = new CommandResponse(true);
8303       defaultInstance.initFields();
8304     }
8305
8306     // @@protoc_insertion_point(class_scope:openxc.CommandResponse)
8307   }
8308
8309   public interface DiagnosticRequestOrBuilder
8310       extends com.google.protobuf.MessageOrBuilder {
8311
8312     // optional int32 bus = 1;
8313     boolean hasBus();
8314     int getBus();
8315
8316     // optional uint32 message_id = 2;
8317     boolean hasMessageId();
8318     int getMessageId();
8319
8320     // optional uint32 mode = 3;
8321     boolean hasMode();
8322     int getMode();
8323
8324     // optional uint32 pid = 4;
8325     boolean hasPid();
8326     int getPid();
8327
8328     // optional bytes payload = 5;
8329     boolean hasPayload();
8330     com.google.protobuf.ByteString getPayload();
8331
8332     // optional bool multiple_responses = 6;
8333     boolean hasMultipleResponses();
8334     boolean getMultipleResponses();
8335
8336     // optional double frequency = 7;
8337     boolean hasFrequency();
8338     double getFrequency();
8339
8340     // optional string name = 8;
8341     boolean hasName();
8342     String getName();
8343
8344     // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
8345     boolean hasDecodedType();
8346     com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType();
8347   }
8348   public static final class DiagnosticRequest extends
8349       com.google.protobuf.GeneratedMessage
8350       implements DiagnosticRequestOrBuilder {
8351     // Use DiagnosticRequest.newBuilder() to construct.
8352     private DiagnosticRequest(Builder builder) {
8353       super(builder);
8354     }
8355     private DiagnosticRequest(boolean noInit) {}
8356
8357     private static final DiagnosticRequest defaultInstance;
8358     public static DiagnosticRequest getDefaultInstance() {
8359       return defaultInstance;
8360     }
8361
8362     public DiagnosticRequest getDefaultInstanceForType() {
8363       return defaultInstance;
8364     }
8365
8366     public static final com.google.protobuf.Descriptors.Descriptor
8367         getDescriptor() {
8368       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
8369     }
8370
8371     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
8372         internalGetFieldAccessorTable() {
8373       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_fieldAccessorTable;
8374     }
8375
8376     public enum DecodedType
8377         implements com.google.protobuf.ProtocolMessageEnum {
8378       NONE(0, 1),
8379       OBD2(1, 2),
8380       ;
8381
8382       public static final int NONE_VALUE = 1;
8383       public static final int OBD2_VALUE = 2;
8384
8385
8386       public final int getNumber() { return value; }
8387
8388       public static DecodedType valueOf(int value) {
8389         switch (value) {
8390           case 1: return NONE;
8391           case 2: return OBD2;
8392           default: return null;
8393         }
8394       }
8395
8396       public static com.google.protobuf.Internal.EnumLiteMap<DecodedType>
8397           internalGetValueMap() {
8398         return internalValueMap;
8399       }
8400       private static com.google.protobuf.Internal.EnumLiteMap<DecodedType>
8401           internalValueMap =
8402             new com.google.protobuf.Internal.EnumLiteMap<DecodedType>() {
8403               public DecodedType findValueByNumber(int number) {
8404                 return DecodedType.valueOf(number);
8405               }
8406             };
8407
8408       public final com.google.protobuf.Descriptors.EnumValueDescriptor
8409           getValueDescriptor() {
8410         return getDescriptor().getValues().get(index);
8411       }
8412       public final com.google.protobuf.Descriptors.EnumDescriptor
8413           getDescriptorForType() {
8414         return getDescriptor();
8415       }
8416       public static final com.google.protobuf.Descriptors.EnumDescriptor
8417           getDescriptor() {
8418         return com.openxc.BinaryMessages.DiagnosticRequest.getDescriptor().getEnumTypes().get(0);
8419       }
8420
8421       private static final DecodedType[] VALUES = {
8422         NONE, OBD2,
8423       };
8424
8425       public static DecodedType valueOf(
8426           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
8427         if (desc.getType() != getDescriptor()) {
8428           throw new java.lang.IllegalArgumentException(
8429             "EnumValueDescriptor is not for this type.");
8430         }
8431         return VALUES[desc.getIndex()];
8432       }
8433
8434       private final int index;
8435       private final int value;
8436
8437       private DecodedType(int index, int value) {
8438         this.index = index;
8439         this.value = value;
8440       }
8441
8442       // @@protoc_insertion_point(enum_scope:openxc.DiagnosticRequest.DecodedType)
8443     }
8444
8445     private int bitField0_;
8446     // optional int32 bus = 1;
8447     public static final int BUS_FIELD_NUMBER = 1;
8448     private int bus_;
8449     public boolean hasBus() {
8450       return ((bitField0_ & 0x00000001) == 0x00000001);
8451     }
8452     public int getBus() {
8453       return bus_;
8454     }
8455
8456     // optional uint32 message_id = 2;
8457     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
8458     private int messageId_;
8459     public boolean hasMessageId() {
8460       return ((bitField0_ & 0x00000002) == 0x00000002);
8461     }
8462     public int getMessageId() {
8463       return messageId_;
8464     }
8465
8466     // optional uint32 mode = 3;
8467     public static final int MODE_FIELD_NUMBER = 3;
8468     private int mode_;
8469     public boolean hasMode() {
8470       return ((bitField0_ & 0x00000004) == 0x00000004);
8471     }
8472     public int getMode() {
8473       return mode_;
8474     }
8475
8476     // optional uint32 pid = 4;
8477     public static final int PID_FIELD_NUMBER = 4;
8478     private int pid_;
8479     public boolean hasPid() {
8480       return ((bitField0_ & 0x00000008) == 0x00000008);
8481     }
8482     public int getPid() {
8483       return pid_;
8484     }
8485
8486     // optional bytes payload = 5;
8487     public static final int PAYLOAD_FIELD_NUMBER = 5;
8488     private com.google.protobuf.ByteString payload_;
8489     public boolean hasPayload() {
8490       return ((bitField0_ & 0x00000010) == 0x00000010);
8491     }
8492     public com.google.protobuf.ByteString getPayload() {
8493       return payload_;
8494     }
8495
8496     // optional bool multiple_responses = 6;
8497     public static final int MULTIPLE_RESPONSES_FIELD_NUMBER = 6;
8498     private boolean multipleResponses_;
8499     public boolean hasMultipleResponses() {
8500       return ((bitField0_ & 0x00000020) == 0x00000020);
8501     }
8502     public boolean getMultipleResponses() {
8503       return multipleResponses_;
8504     }
8505
8506     // optional double frequency = 7;
8507     public static final int FREQUENCY_FIELD_NUMBER = 7;
8508     private double frequency_;
8509     public boolean hasFrequency() {
8510       return ((bitField0_ & 0x00000040) == 0x00000040);
8511     }
8512     public double getFrequency() {
8513       return frequency_;
8514     }
8515
8516     // optional string name = 8;
8517     public static final int NAME_FIELD_NUMBER = 8;
8518     private java.lang.Object name_;
8519     public boolean hasName() {
8520       return ((bitField0_ & 0x00000080) == 0x00000080);
8521     }
8522     public String getName() {
8523       java.lang.Object ref = name_;
8524       if (ref instanceof String) {
8525         return (String) ref;
8526       } else {
8527         com.google.protobuf.ByteString bs =
8528             (com.google.protobuf.ByteString) ref;
8529         String s = bs.toStringUtf8();
8530         if (com.google.protobuf.Internal.isValidUtf8(bs)) {
8531           name_ = s;
8532         }
8533         return s;
8534       }
8535     }
8536     private com.google.protobuf.ByteString getNameBytes() {
8537       java.lang.Object ref = name_;
8538       if (ref instanceof String) {
8539         com.google.protobuf.ByteString b =
8540             com.google.protobuf.ByteString.copyFromUtf8((String) ref);
8541         name_ = b;
8542         return b;
8543       } else {
8544         return (com.google.protobuf.ByteString) ref;
8545       }
8546     }
8547
8548     // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
8549     public static final int DECODED_TYPE_FIELD_NUMBER = 9;
8550     private com.openxc.BinaryMessages.DiagnosticRequest.DecodedType decodedType_;
8551     public boolean hasDecodedType() {
8552       return ((bitField0_ & 0x00000100) == 0x00000100);
8553     }
8554     public com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType() {
8555       return decodedType_;
8556     }
8557
8558     private void initFields() {
8559       bus_ = 0;
8560       messageId_ = 0;
8561       mode_ = 0;
8562       pid_ = 0;
8563       payload_ = com.google.protobuf.ByteString.EMPTY;
8564       multipleResponses_ = false;
8565       frequency_ = 0D;
8566       name_ = "";
8567       decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
8568     }
8569     private byte memoizedIsInitialized = -1;
8570     public final boolean isInitialized() {
8571       byte isInitialized = memoizedIsInitialized;
8572       if (isInitialized != -1) return isInitialized == 1;
8573
8574       memoizedIsInitialized = 1;
8575       return true;
8576     }
8577
8578     public void writeTo(com.google.protobuf.CodedOutputStream output)
8579                         throws java.io.IOException {
8580       getSerializedSize();
8581       if (((bitField0_ & 0x00000001) == 0x00000001)) {
8582         output.writeInt32(1, bus_);
8583       }
8584       if (((bitField0_ & 0x00000002) == 0x00000002)) {
8585         output.writeUInt32(2, messageId_);
8586       }
8587       if (((bitField0_ & 0x00000004) == 0x00000004)) {
8588         output.writeUInt32(3, mode_);
8589       }
8590       if (((bitField0_ & 0x00000008) == 0x00000008)) {
8591         output.writeUInt32(4, pid_);
8592       }
8593       if (((bitField0_ & 0x00000010) == 0x00000010)) {
8594         output.writeBytes(5, payload_);
8595       }
8596       if (((bitField0_ & 0x00000020) == 0x00000020)) {
8597         output.writeBool(6, multipleResponses_);
8598       }
8599       if (((bitField0_ & 0x00000040) == 0x00000040)) {
8600         output.writeDouble(7, frequency_);
8601       }
8602       if (((bitField0_ & 0x00000080) == 0x00000080)) {
8603         output.writeBytes(8, getNameBytes());
8604       }
8605       if (((bitField0_ & 0x00000100) == 0x00000100)) {
8606         output.writeEnum(9, decodedType_.getNumber());
8607       }
8608       getUnknownFields().writeTo(output);
8609     }
8610
8611     private int memoizedSerializedSize = -1;
8612     public int getSerializedSize() {
8613       int size = memoizedSerializedSize;
8614       if (size != -1) return size;
8615
8616       size = 0;
8617       if (((bitField0_ & 0x00000001) == 0x00000001)) {
8618         size += com.google.protobuf.CodedOutputStream
8619           .computeInt32Size(1, bus_);
8620       }
8621       if (((bitField0_ & 0x00000002) == 0x00000002)) {
8622         size += com.google.protobuf.CodedOutputStream
8623           .computeUInt32Size(2, messageId_);
8624       }
8625       if (((bitField0_ & 0x00000004) == 0x00000004)) {
8626         size += com.google.protobuf.CodedOutputStream
8627           .computeUInt32Size(3, mode_);
8628       }
8629       if (((bitField0_ & 0x00000008) == 0x00000008)) {
8630         size += com.google.protobuf.CodedOutputStream
8631           .computeUInt32Size(4, pid_);
8632       }
8633       if (((bitField0_ & 0x00000010) == 0x00000010)) {
8634         size += com.google.protobuf.CodedOutputStream
8635           .computeBytesSize(5, payload_);
8636       }
8637       if (((bitField0_ & 0x00000020) == 0x00000020)) {
8638         size += com.google.protobuf.CodedOutputStream
8639           .computeBoolSize(6, multipleResponses_);
8640       }
8641       if (((bitField0_ & 0x00000040) == 0x00000040)) {
8642         size += com.google.protobuf.CodedOutputStream
8643           .computeDoubleSize(7, frequency_);
8644       }
8645       if (((bitField0_ & 0x00000080) == 0x00000080)) {
8646         size += com.google.protobuf.CodedOutputStream
8647           .computeBytesSize(8, getNameBytes());
8648       }
8649       if (((bitField0_ & 0x00000100) == 0x00000100)) {
8650         size += com.google.protobuf.CodedOutputStream
8651           .computeEnumSize(9, decodedType_.getNumber());
8652       }
8653       size += getUnknownFields().getSerializedSize();
8654       memoizedSerializedSize = size;
8655       return size;
8656     }
8657
8658     private static final long serialVersionUID = 0L;
8659     @java.lang.Override
8660     protected java.lang.Object writeReplace()
8661         throws java.io.ObjectStreamException {
8662       return super.writeReplace();
8663     }
8664
8665     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
8666         com.google.protobuf.ByteString data)
8667         throws com.google.protobuf.InvalidProtocolBufferException {
8668       return newBuilder().mergeFrom(data).buildParsed();
8669     }
8670     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
8671         com.google.protobuf.ByteString data,
8672         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8673         throws com.google.protobuf.InvalidProtocolBufferException {
8674       return newBuilder().mergeFrom(data, extensionRegistry)
8675                .buildParsed();
8676     }
8677     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(byte[] data)
8678         throws com.google.protobuf.InvalidProtocolBufferException {
8679       return newBuilder().mergeFrom(data).buildParsed();
8680     }
8681     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
8682         byte[] data,
8683         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8684         throws com.google.protobuf.InvalidProtocolBufferException {
8685       return newBuilder().mergeFrom(data, extensionRegistry)
8686                .buildParsed();
8687     }
8688     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(java.io.InputStream input)
8689         throws java.io.IOException {
8690       return newBuilder().mergeFrom(input).buildParsed();
8691     }
8692     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
8693         java.io.InputStream input,
8694         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8695         throws java.io.IOException {
8696       return newBuilder().mergeFrom(input, extensionRegistry)
8697                .buildParsed();
8698     }
8699     public static com.openxc.BinaryMessages.DiagnosticRequest parseDelimitedFrom(java.io.InputStream input)
8700         throws java.io.IOException {
8701       Builder builder = newBuilder();
8702       if (builder.mergeDelimitedFrom(input)) {
8703         return builder.buildParsed();
8704       } else {
8705         return null;
8706       }
8707     }
8708     public static com.openxc.BinaryMessages.DiagnosticRequest parseDelimitedFrom(
8709         java.io.InputStream input,
8710         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8711         throws java.io.IOException {
8712       Builder builder = newBuilder();
8713       if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
8714         return builder.buildParsed();
8715       } else {
8716         return null;
8717       }
8718     }
8719     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
8720         com.google.protobuf.CodedInputStream input)
8721         throws java.io.IOException {
8722       return newBuilder().mergeFrom(input).buildParsed();
8723     }
8724     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
8725         com.google.protobuf.CodedInputStream input,
8726         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8727         throws java.io.IOException {
8728       return newBuilder().mergeFrom(input, extensionRegistry)
8729                .buildParsed();
8730     }
8731
8732     public static Builder newBuilder() { return Builder.create(); }
8733     public Builder newBuilderForType() { return newBuilder(); }
8734     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticRequest prototype) {
8735       return newBuilder().mergeFrom(prototype);
8736     }
8737     public Builder toBuilder() { return newBuilder(this); }
8738
8739     @java.lang.Override
8740     protected Builder newBuilderForType(
8741         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
8742       Builder builder = new Builder(parent);
8743       return builder;
8744     }
8745     public static final class Builder extends
8746         com.google.protobuf.GeneratedMessage.Builder<Builder>
8747        implements com.openxc.BinaryMessages.DiagnosticRequestOrBuilder {
8748       public static final com.google.protobuf.Descriptors.Descriptor
8749           getDescriptor() {
8750         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
8751       }
8752
8753       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
8754           internalGetFieldAccessorTable() {
8755         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_fieldAccessorTable;
8756       }
8757
8758       // Construct using com.openxc.BinaryMessages.DiagnosticRequest.newBuilder()
8759       private Builder() {
8760         maybeForceBuilderInitialization();
8761       }
8762
8763       private Builder(BuilderParent parent) {
8764         super(parent);
8765         maybeForceBuilderInitialization();
8766       }
8767       private void maybeForceBuilderInitialization() {
8768         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
8769         }
8770       }
8771       private static Builder create() {
8772         return new Builder();
8773       }
8774
8775       public Builder clear() {
8776         super.clear();
8777         bus_ = 0;
8778         bitField0_ = (bitField0_ & ~0x00000001);
8779         messageId_ = 0;
8780         bitField0_ = (bitField0_ & ~0x00000002);
8781         mode_ = 0;
8782         bitField0_ = (bitField0_ & ~0x00000004);
8783         pid_ = 0;
8784         bitField0_ = (bitField0_ & ~0x00000008);
8785         payload_ = com.google.protobuf.ByteString.EMPTY;
8786         bitField0_ = (bitField0_ & ~0x00000010);
8787         multipleResponses_ = false;
8788         bitField0_ = (bitField0_ & ~0x00000020);
8789         frequency_ = 0D;
8790         bitField0_ = (bitField0_ & ~0x00000040);
8791         name_ = "";
8792         bitField0_ = (bitField0_ & ~0x00000080);
8793         decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
8794         bitField0_ = (bitField0_ & ~0x00000100);
8795         return this;
8796       }
8797
8798       public Builder clone() {
8799         return create().mergeFrom(buildPartial());
8800       }
8801
8802       public com.google.protobuf.Descriptors.Descriptor
8803           getDescriptorForType() {
8804         return com.openxc.BinaryMessages.DiagnosticRequest.getDescriptor();
8805       }
8806
8807       public com.openxc.BinaryMessages.DiagnosticRequest getDefaultInstanceForType() {
8808         return com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
8809       }
8810
8811       public com.openxc.BinaryMessages.DiagnosticRequest build() {
8812         com.openxc.BinaryMessages.DiagnosticRequest result = buildPartial();
8813         if (!result.isInitialized()) {
8814           throw newUninitializedMessageException(result);
8815         }
8816         return result;
8817       }
8818
8819       private com.openxc.BinaryMessages.DiagnosticRequest buildParsed()
8820           throws com.google.protobuf.InvalidProtocolBufferException {
8821         com.openxc.BinaryMessages.DiagnosticRequest result = buildPartial();
8822         if (!result.isInitialized()) {
8823           throw newUninitializedMessageException(
8824             result).asInvalidProtocolBufferException();
8825         }
8826         return result;
8827       }
8828
8829       public com.openxc.BinaryMessages.DiagnosticRequest buildPartial() {
8830         com.openxc.BinaryMessages.DiagnosticRequest result = new com.openxc.BinaryMessages.DiagnosticRequest(this);
8831         int from_bitField0_ = bitField0_;
8832         int to_bitField0_ = 0;
8833         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
8834           to_bitField0_ |= 0x00000001;
8835         }
8836         result.bus_ = bus_;
8837         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
8838           to_bitField0_ |= 0x00000002;
8839         }
8840         result.messageId_ = messageId_;
8841         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
8842           to_bitField0_ |= 0x00000004;
8843         }
8844         result.mode_ = mode_;
8845         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
8846           to_bitField0_ |= 0x00000008;
8847         }
8848         result.pid_ = pid_;
8849         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
8850           to_bitField0_ |= 0x00000010;
8851         }
8852         result.payload_ = payload_;
8853         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
8854           to_bitField0_ |= 0x00000020;
8855         }
8856         result.multipleResponses_ = multipleResponses_;
8857         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
8858           to_bitField0_ |= 0x00000040;
8859         }
8860         result.frequency_ = frequency_;
8861         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
8862           to_bitField0_ |= 0x00000080;
8863         }
8864         result.name_ = name_;
8865         if (((from_bitField0_ & 0x00000100) == 0x00000100)) {
8866           to_bitField0_ |= 0x00000100;
8867         }
8868         result.decodedType_ = decodedType_;
8869         result.bitField0_ = to_bitField0_;
8870         onBuilt();
8871         return result;
8872       }
8873
8874       public Builder mergeFrom(com.google.protobuf.Message other) {
8875         if (other instanceof com.openxc.BinaryMessages.DiagnosticRequest) {
8876           return mergeFrom((com.openxc.BinaryMessages.DiagnosticRequest)other);
8877         } else {
8878           super.mergeFrom(other);
8879           return this;
8880         }
8881       }
8882
8883       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticRequest other) {
8884         if (other == com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance()) return this;
8885         if (other.hasBus()) {
8886           setBus(other.getBus());
8887         }
8888         if (other.hasMessageId()) {
8889           setMessageId(other.getMessageId());
8890         }
8891         if (other.hasMode()) {
8892           setMode(other.getMode());
8893         }
8894         if (other.hasPid()) {
8895           setPid(other.getPid());
8896         }
8897         if (other.hasPayload()) {
8898           setPayload(other.getPayload());
8899         }
8900         if (other.hasMultipleResponses()) {
8901           setMultipleResponses(other.getMultipleResponses());
8902         }
8903         if (other.hasFrequency()) {
8904           setFrequency(other.getFrequency());
8905         }
8906         if (other.hasName()) {
8907           setName(other.getName());
8908         }
8909         if (other.hasDecodedType()) {
8910           setDecodedType(other.getDecodedType());
8911         }
8912         this.mergeUnknownFields(other.getUnknownFields());
8913         return this;
8914       }
8915
8916       public final boolean isInitialized() {
8917         return true;
8918       }
8919
8920       public Builder mergeFrom(
8921           com.google.protobuf.CodedInputStream input,
8922           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8923           throws java.io.IOException {
8924         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
8925           com.google.protobuf.UnknownFieldSet.newBuilder(
8926             this.getUnknownFields());
8927         while (true) {
8928           int tag = input.readTag();
8929           switch (tag) {
8930             case 0:
8931               this.setUnknownFields(unknownFields.build());
8932               onChanged();
8933               return this;
8934             default: {
8935               if (!parseUnknownField(input, unknownFields,
8936                                      extensionRegistry, tag)) {
8937                 this.setUnknownFields(unknownFields.build());
8938                 onChanged();
8939                 return this;
8940               }
8941               break;
8942             }
8943             case 8: {
8944               bitField0_ |= 0x00000001;
8945               bus_ = input.readInt32();
8946               break;
8947             }
8948             case 16: {
8949               bitField0_ |= 0x00000002;
8950               messageId_ = input.readUInt32();
8951               break;
8952             }
8953             case 24: {
8954               bitField0_ |= 0x00000004;
8955               mode_ = input.readUInt32();
8956               break;
8957             }
8958             case 32: {
8959               bitField0_ |= 0x00000008;
8960               pid_ = input.readUInt32();
8961               break;
8962             }
8963             case 42: {
8964               bitField0_ |= 0x00000010;
8965               payload_ = input.readBytes();
8966               break;
8967             }
8968             case 48: {
8969               bitField0_ |= 0x00000020;
8970               multipleResponses_ = input.readBool();
8971               break;
8972             }
8973             case 57: {
8974               bitField0_ |= 0x00000040;
8975               frequency_ = input.readDouble();
8976               break;
8977             }
8978             case 66: {
8979               bitField0_ |= 0x00000080;
8980               name_ = input.readBytes();
8981               break;
8982             }
8983             case 72: {
8984               int rawValue = input.readEnum();
8985               com.openxc.BinaryMessages.DiagnosticRequest.DecodedType value = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.valueOf(rawValue);
8986               if (value == null) {
8987                 unknownFields.mergeVarintField(9, rawValue);
8988               } else {
8989                 bitField0_ |= 0x00000100;
8990                 decodedType_ = value;
8991               }
8992               break;
8993             }
8994           }
8995         }
8996       }
8997
8998       private int bitField0_;
8999
9000       // optional int32 bus = 1;
9001       private int bus_ ;
9002       public boolean hasBus() {
9003         return ((bitField0_ & 0x00000001) == 0x00000001);
9004       }
9005       public int getBus() {
9006         return bus_;
9007       }
9008       public Builder setBus(int value) {
9009         bitField0_ |= 0x00000001;
9010         bus_ = value;
9011         onChanged();
9012         return this;
9013       }
9014       public Builder clearBus() {
9015         bitField0_ = (bitField0_ & ~0x00000001);
9016         bus_ = 0;
9017         onChanged();
9018         return this;
9019       }
9020
9021       // optional uint32 message_id = 2;
9022       private int messageId_ ;
9023       public boolean hasMessageId() {
9024         return ((bitField0_ & 0x00000002) == 0x00000002);
9025       }
9026       public int getMessageId() {
9027         return messageId_;
9028       }
9029       public Builder setMessageId(int value) {
9030         bitField0_ |= 0x00000002;
9031         messageId_ = value;
9032         onChanged();
9033         return this;
9034       }
9035       public Builder clearMessageId() {
9036         bitField0_ = (bitField0_ & ~0x00000002);
9037         messageId_ = 0;
9038         onChanged();
9039         return this;
9040       }
9041
9042       // optional uint32 mode = 3;
9043       private int mode_ ;
9044       public boolean hasMode() {
9045         return ((bitField0_ & 0x00000004) == 0x00000004);
9046       }
9047       public int getMode() {
9048         return mode_;
9049       }
9050       public Builder setMode(int value) {
9051         bitField0_ |= 0x00000004;
9052         mode_ = value;
9053         onChanged();
9054         return this;
9055       }
9056       public Builder clearMode() {
9057         bitField0_ = (bitField0_ & ~0x00000004);
9058         mode_ = 0;
9059         onChanged();
9060         return this;
9061       }
9062
9063       // optional uint32 pid = 4;
9064       private int pid_ ;
9065       public boolean hasPid() {
9066         return ((bitField0_ & 0x00000008) == 0x00000008);
9067       }
9068       public int getPid() {
9069         return pid_;
9070       }
9071       public Builder setPid(int value) {
9072         bitField0_ |= 0x00000008;
9073         pid_ = value;
9074         onChanged();
9075         return this;
9076       }
9077       public Builder clearPid() {
9078         bitField0_ = (bitField0_ & ~0x00000008);
9079         pid_ = 0;
9080         onChanged();
9081         return this;
9082       }
9083
9084       // optional bytes payload = 5;
9085       private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY;
9086       public boolean hasPayload() {
9087         return ((bitField0_ & 0x00000010) == 0x00000010);
9088       }
9089       public com.google.protobuf.ByteString getPayload() {
9090         return payload_;
9091       }
9092       public Builder setPayload(com.google.protobuf.ByteString value) {
9093         if (value == null) {
9094     throw new NullPointerException();
9095   }
9096   bitField0_ |= 0x00000010;
9097         payload_ = value;
9098         onChanged();
9099         return this;
9100       }
9101       public Builder clearPayload() {
9102         bitField0_ = (bitField0_ & ~0x00000010);
9103         payload_ = getDefaultInstance().getPayload();
9104         onChanged();
9105         return this;
9106       }
9107
9108       // optional bool multiple_responses = 6;
9109       private boolean multipleResponses_ ;
9110       public boolean hasMultipleResponses() {
9111         return ((bitField0_ & 0x00000020) == 0x00000020);
9112       }
9113       public boolean getMultipleResponses() {
9114         return multipleResponses_;
9115       }
9116       public Builder setMultipleResponses(boolean value) {
9117         bitField0_ |= 0x00000020;
9118         multipleResponses_ = value;
9119         onChanged();
9120         return this;
9121       }
9122       public Builder clearMultipleResponses() {
9123         bitField0_ = (bitField0_ & ~0x00000020);
9124         multipleResponses_ = false;
9125         onChanged();
9126         return this;
9127       }
9128
9129       // optional double frequency = 7;
9130       private double frequency_ ;
9131       public boolean hasFrequency() {
9132         return ((bitField0_ & 0x00000040) == 0x00000040);
9133       }
9134       public double getFrequency() {
9135         return frequency_;
9136       }
9137       public Builder setFrequency(double value) {
9138         bitField0_ |= 0x00000040;
9139         frequency_ = value;
9140         onChanged();
9141         return this;
9142       }
9143       public Builder clearFrequency() {
9144         bitField0_ = (bitField0_ & ~0x00000040);
9145         frequency_ = 0D;
9146         onChanged();
9147         return this;
9148       }
9149
9150       // optional string name = 8;
9151       private java.lang.Object name_ = "";
9152       public boolean hasName() {
9153         return ((bitField0_ & 0x00000080) == 0x00000080);
9154       }
9155       public String getName() {
9156         java.lang.Object ref = name_;
9157         if (!(ref instanceof String)) {
9158           String s = ((com.google.protobuf.ByteString) ref).toStringUtf8();
9159           name_ = s;
9160           return s;
9161         } else {
9162           return (String) ref;
9163         }
9164       }
9165       public Builder setName(String value) {
9166         if (value == null) {
9167     throw new NullPointerException();
9168   }
9169   bitField0_ |= 0x00000080;
9170         name_ = value;
9171         onChanged();
9172         return this;
9173       }
9174       public Builder clearName() {
9175         bitField0_ = (bitField0_ & ~0x00000080);
9176         name_ = getDefaultInstance().getName();
9177         onChanged();
9178         return this;
9179       }
9180       void setName(com.google.protobuf.ByteString value) {
9181         bitField0_ |= 0x00000080;
9182         name_ = value;
9183         onChanged();
9184       }
9185
9186       // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
9187       private com.openxc.BinaryMessages.DiagnosticRequest.DecodedType decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
9188       public boolean hasDecodedType() {
9189         return ((bitField0_ & 0x00000100) == 0x00000100);
9190       }
9191       public com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType() {
9192         return decodedType_;
9193       }
9194       public Builder setDecodedType(com.openxc.BinaryMessages.DiagnosticRequest.DecodedType value) {
9195         if (value == null) {
9196           throw new NullPointerException();
9197         }
9198         bitField0_ |= 0x00000100;
9199         decodedType_ = value;
9200         onChanged();
9201         return this;
9202       }
9203       public Builder clearDecodedType() {
9204         bitField0_ = (bitField0_ & ~0x00000100);
9205         decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
9206         onChanged();
9207         return this;
9208       }
9209
9210       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticRequest)
9211     }
9212
9213     static {
9214       defaultInstance = new DiagnosticRequest(true);
9215       defaultInstance.initFields();
9216     }
9217
9218     // @@protoc_insertion_point(class_scope:openxc.DiagnosticRequest)
9219   }
9220
9221   public interface DiagnosticResponseOrBuilder
9222       extends com.google.protobuf.MessageOrBuilder {
9223
9224     // optional int32 bus = 1;
9225     boolean hasBus();
9226     int getBus();
9227
9228     // optional uint32 message_id = 2;
9229     boolean hasMessageId();
9230     int getMessageId();
9231
9232     // optional uint32 mode = 3;
9233     boolean hasMode();
9234     int getMode();
9235
9236     // optional uint32 pid = 4;
9237     boolean hasPid();
9238     int getPid();
9239
9240     // optional bool success = 5;
9241     boolean hasSuccess();
9242     boolean getSuccess();
9243
9244     // optional uint32 negative_response_code = 6;
9245     boolean hasNegativeResponseCode();
9246     int getNegativeResponseCode();
9247
9248     // optional bytes payload = 7;
9249     boolean hasPayload();
9250     com.google.protobuf.ByteString getPayload();
9251
9252     // optional double value = 8;
9253     boolean hasValue();
9254     double getValue();
9255   }
9256   public static final class DiagnosticResponse extends
9257       com.google.protobuf.GeneratedMessage
9258       implements DiagnosticResponseOrBuilder {
9259     // Use DiagnosticResponse.newBuilder() to construct.
9260     private DiagnosticResponse(Builder builder) {
9261       super(builder);
9262     }
9263     private DiagnosticResponse(boolean noInit) {}
9264
9265     private static final DiagnosticResponse defaultInstance;
9266     public static DiagnosticResponse getDefaultInstance() {
9267       return defaultInstance;
9268     }
9269
9270     public DiagnosticResponse getDefaultInstanceForType() {
9271       return defaultInstance;
9272     }
9273
9274     public static final com.google.protobuf.Descriptors.Descriptor
9275         getDescriptor() {
9276       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
9277     }
9278
9279     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
9280         internalGetFieldAccessorTable() {
9281       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_fieldAccessorTable;
9282     }
9283
9284     private int bitField0_;
9285     // optional int32 bus = 1;
9286     public static final int BUS_FIELD_NUMBER = 1;
9287     private int bus_;
9288     public boolean hasBus() {
9289       return ((bitField0_ & 0x00000001) == 0x00000001);
9290     }
9291     public int getBus() {
9292       return bus_;
9293     }
9294
9295     // optional uint32 message_id = 2;
9296     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
9297     private int messageId_;
9298     public boolean hasMessageId() {
9299       return ((bitField0_ & 0x00000002) == 0x00000002);
9300     }
9301     public int getMessageId() {
9302       return messageId_;
9303     }
9304
9305     // optional uint32 mode = 3;
9306     public static final int MODE_FIELD_NUMBER = 3;
9307     private int mode_;
9308     public boolean hasMode() {
9309       return ((bitField0_ & 0x00000004) == 0x00000004);
9310     }
9311     public int getMode() {
9312       return mode_;
9313     }
9314
9315     // optional uint32 pid = 4;
9316     public static final int PID_FIELD_NUMBER = 4;
9317     private int pid_;
9318     public boolean hasPid() {
9319       return ((bitField0_ & 0x00000008) == 0x00000008);
9320     }
9321     public int getPid() {
9322       return pid_;
9323     }
9324
9325     // optional bool success = 5;
9326     public static final int SUCCESS_FIELD_NUMBER = 5;
9327     private boolean success_;
9328     public boolean hasSuccess() {
9329       return ((bitField0_ & 0x00000010) == 0x00000010);
9330     }
9331     public boolean getSuccess() {
9332       return success_;
9333     }
9334
9335     // optional uint32 negative_response_code = 6;
9336     public static final int NEGATIVE_RESPONSE_CODE_FIELD_NUMBER = 6;
9337     private int negativeResponseCode_;
9338     public boolean hasNegativeResponseCode() {
9339       return ((bitField0_ & 0x00000020) == 0x00000020);
9340     }
9341     public int getNegativeResponseCode() {
9342       return negativeResponseCode_;
9343     }
9344
9345     // optional bytes payload = 7;
9346     public static final int PAYLOAD_FIELD_NUMBER = 7;
9347     private com.google.protobuf.ByteString payload_;
9348     public boolean hasPayload() {
9349       return ((bitField0_ & 0x00000040) == 0x00000040);
9350     }
9351     public com.google.protobuf.ByteString getPayload() {
9352       return payload_;
9353     }
9354
9355     // optional double value = 8;
9356     public static final int VALUE_FIELD_NUMBER = 8;
9357     private double value_;
9358     public boolean hasValue() {
9359       return ((bitField0_ & 0x00000080) == 0x00000080);
9360     }
9361     public double getValue() {
9362       return value_;
9363     }
9364
9365     private void initFields() {
9366       bus_ = 0;
9367       messageId_ = 0;
9368       mode_ = 0;
9369       pid_ = 0;
9370       success_ = false;
9371       negativeResponseCode_ = 0;
9372       payload_ = com.google.protobuf.ByteString.EMPTY;
9373       value_ = 0D;
9374     }
9375     private byte memoizedIsInitialized = -1;
9376     public final boolean isInitialized() {
9377       byte isInitialized = memoizedIsInitialized;
9378       if (isInitialized != -1) return isInitialized == 1;
9379
9380       memoizedIsInitialized = 1;
9381       return true;
9382     }
9383
9384     public void writeTo(com.google.protobuf.CodedOutputStream output)
9385                         throws java.io.IOException {
9386       getSerializedSize();
9387       if (((bitField0_ & 0x00000001) == 0x00000001)) {
9388         output.writeInt32(1, bus_);
9389       }
9390       if (((bitField0_ & 0x00000002) == 0x00000002)) {
9391         output.writeUInt32(2, messageId_);
9392       }
9393       if (((bitField0_ & 0x00000004) == 0x00000004)) {
9394         output.writeUInt32(3, mode_);
9395       }
9396       if (((bitField0_ & 0x00000008) == 0x00000008)) {
9397         output.writeUInt32(4, pid_);
9398       }
9399       if (((bitField0_ & 0x00000010) == 0x00000010)) {
9400         output.writeBool(5, success_);
9401       }
9402       if (((bitField0_ & 0x00000020) == 0x00000020)) {
9403         output.writeUInt32(6, negativeResponseCode_);
9404       }
9405       if (((bitField0_ & 0x00000040) == 0x00000040)) {
9406         output.writeBytes(7, payload_);
9407       }
9408       if (((bitField0_ & 0x00000080) == 0x00000080)) {
9409         output.writeDouble(8, value_);
9410       }
9411       getUnknownFields().writeTo(output);
9412     }
9413
9414     private int memoizedSerializedSize = -1;
9415     public int getSerializedSize() {
9416       int size = memoizedSerializedSize;
9417       if (size != -1) return size;
9418
9419       size = 0;
9420       if (((bitField0_ & 0x00000001) == 0x00000001)) {
9421         size += com.google.protobuf.CodedOutputStream
9422           .computeInt32Size(1, bus_);
9423       }
9424       if (((bitField0_ & 0x00000002) == 0x00000002)) {
9425         size += com.google.protobuf.CodedOutputStream
9426           .computeUInt32Size(2, messageId_);
9427       }
9428       if (((bitField0_ & 0x00000004) == 0x00000004)) {
9429         size += com.google.protobuf.CodedOutputStream
9430           .computeUInt32Size(3, mode_);
9431       }
9432       if (((bitField0_ & 0x00000008) == 0x00000008)) {
9433         size += com.google.protobuf.CodedOutputStream
9434           .computeUInt32Size(4, pid_);
9435       }
9436       if (((bitField0_ & 0x00000010) == 0x00000010)) {
9437         size += com.google.protobuf.CodedOutputStream
9438           .computeBoolSize(5, success_);
9439       }
9440       if (((bitField0_ & 0x00000020) == 0x00000020)) {
9441         size += com.google.protobuf.CodedOutputStream
9442           .computeUInt32Size(6, negativeResponseCode_);
9443       }
9444       if (((bitField0_ & 0x00000040) == 0x00000040)) {
9445         size += com.google.protobuf.CodedOutputStream
9446           .computeBytesSize(7, payload_);
9447       }
9448       if (((bitField0_ & 0x00000080) == 0x00000080)) {
9449         size += com.google.protobuf.CodedOutputStream
9450           .computeDoubleSize(8, value_);
9451       }
9452       size += getUnknownFields().getSerializedSize();
9453       memoizedSerializedSize = size;
9454       return size;
9455     }
9456
9457     private static final long serialVersionUID = 0L;
9458     @java.lang.Override
9459     protected java.lang.Object writeReplace()
9460         throws java.io.ObjectStreamException {
9461       return super.writeReplace();
9462     }
9463
9464     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
9465         com.google.protobuf.ByteString data)
9466         throws com.google.protobuf.InvalidProtocolBufferException {
9467       return newBuilder().mergeFrom(data).buildParsed();
9468     }
9469     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
9470         com.google.protobuf.ByteString data,
9471         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9472         throws com.google.protobuf.InvalidProtocolBufferException {
9473       return newBuilder().mergeFrom(data, extensionRegistry)
9474                .buildParsed();
9475     }
9476     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(byte[] data)
9477         throws com.google.protobuf.InvalidProtocolBufferException {
9478       return newBuilder().mergeFrom(data).buildParsed();
9479     }
9480     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
9481         byte[] data,
9482         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9483         throws com.google.protobuf.InvalidProtocolBufferException {
9484       return newBuilder().mergeFrom(data, extensionRegistry)
9485                .buildParsed();
9486     }
9487     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(java.io.InputStream input)
9488         throws java.io.IOException {
9489       return newBuilder().mergeFrom(input).buildParsed();
9490     }
9491     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
9492         java.io.InputStream input,
9493         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9494         throws java.io.IOException {
9495       return newBuilder().mergeFrom(input, extensionRegistry)
9496                .buildParsed();
9497     }
9498     public static com.openxc.BinaryMessages.DiagnosticResponse parseDelimitedFrom(java.io.InputStream input)
9499         throws java.io.IOException {
9500       Builder builder = newBuilder();
9501       if (builder.mergeDelimitedFrom(input)) {
9502         return builder.buildParsed();
9503       } else {
9504         return null;
9505       }
9506     }
9507     public static com.openxc.BinaryMessages.DiagnosticResponse parseDelimitedFrom(
9508         java.io.InputStream input,
9509         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9510         throws java.io.IOException {
9511       Builder builder = newBuilder();
9512       if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
9513         return builder.buildParsed();
9514       } else {
9515         return null;
9516       }
9517     }
9518     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
9519         com.google.protobuf.CodedInputStream input)
9520         throws java.io.IOException {
9521       return newBuilder().mergeFrom(input).buildParsed();
9522     }
9523     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
9524         com.google.protobuf.CodedInputStream input,
9525         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9526         throws java.io.IOException {
9527       return newBuilder().mergeFrom(input, extensionRegistry)
9528                .buildParsed();
9529     }
9530
9531     public static Builder newBuilder() { return Builder.create(); }
9532     public Builder newBuilderForType() { return newBuilder(); }
9533     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticResponse prototype) {
9534       return newBuilder().mergeFrom(prototype);
9535     }
9536     public Builder toBuilder() { return newBuilder(this); }
9537
9538     @java.lang.Override
9539     protected Builder newBuilderForType(
9540         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
9541       Builder builder = new Builder(parent);
9542       return builder;
9543     }
9544     public static final class Builder extends
9545         com.google.protobuf.GeneratedMessage.Builder<Builder>
9546        implements com.openxc.BinaryMessages.DiagnosticResponseOrBuilder {
9547       public static final com.google.protobuf.Descriptors.Descriptor
9548           getDescriptor() {
9549         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
9550       }
9551
9552       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
9553           internalGetFieldAccessorTable() {
9554         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_fieldAccessorTable;
9555       }
9556
9557       // Construct using com.openxc.BinaryMessages.DiagnosticResponse.newBuilder()
9558       private Builder() {
9559         maybeForceBuilderInitialization();
9560       }
9561
9562       private Builder(BuilderParent parent) {
9563         super(parent);
9564         maybeForceBuilderInitialization();
9565       }
9566       private void maybeForceBuilderInitialization() {
9567         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
9568         }
9569       }
9570       private static Builder create() {
9571         return new Builder();
9572       }
9573
9574       public Builder clear() {
9575         super.clear();
9576         bus_ = 0;
9577         bitField0_ = (bitField0_ & ~0x00000001);
9578         messageId_ = 0;
9579         bitField0_ = (bitField0_ & ~0x00000002);
9580         mode_ = 0;
9581         bitField0_ = (bitField0_ & ~0x00000004);
9582         pid_ = 0;
9583         bitField0_ = (bitField0_ & ~0x00000008);
9584         success_ = false;
9585         bitField0_ = (bitField0_ & ~0x00000010);
9586         negativeResponseCode_ = 0;
9587         bitField0_ = (bitField0_ & ~0x00000020);
9588         payload_ = com.google.protobuf.ByteString.EMPTY;
9589         bitField0_ = (bitField0_ & ~0x00000040);
9590         value_ = 0D;
9591         bitField0_ = (bitField0_ & ~0x00000080);
9592         return this;
9593       }
9594
9595       public Builder clone() {
9596         return create().mergeFrom(buildPartial());
9597       }
9598
9599       public com.google.protobuf.Descriptors.Descriptor
9600           getDescriptorForType() {
9601         return com.openxc.BinaryMessages.DiagnosticResponse.getDescriptor();
9602       }
9603
9604       public com.openxc.BinaryMessages.DiagnosticResponse getDefaultInstanceForType() {
9605         return com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
9606       }
9607
9608       public com.openxc.BinaryMessages.DiagnosticResponse build() {
9609         com.openxc.BinaryMessages.DiagnosticResponse result = buildPartial();
9610         if (!result.isInitialized()) {
9611           throw newUninitializedMessageException(result);
9612         }
9613         return result;
9614       }
9615
9616       private com.openxc.BinaryMessages.DiagnosticResponse buildParsed()
9617           throws com.google.protobuf.InvalidProtocolBufferException {
9618         com.openxc.BinaryMessages.DiagnosticResponse result = buildPartial();
9619         if (!result.isInitialized()) {
9620           throw newUninitializedMessageException(
9621             result).asInvalidProtocolBufferException();
9622         }
9623         return result;
9624       }
9625
9626       public com.openxc.BinaryMessages.DiagnosticResponse buildPartial() {
9627         com.openxc.BinaryMessages.DiagnosticResponse result = new com.openxc.BinaryMessages.DiagnosticResponse(this);
9628         int from_bitField0_ = bitField0_;
9629         int to_bitField0_ = 0;
9630         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
9631           to_bitField0_ |= 0x00000001;
9632         }
9633         result.bus_ = bus_;
9634         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
9635           to_bitField0_ |= 0x00000002;
9636         }
9637         result.messageId_ = messageId_;
9638         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
9639           to_bitField0_ |= 0x00000004;
9640         }
9641         result.mode_ = mode_;
9642         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
9643           to_bitField0_ |= 0x00000008;
9644         }
9645         result.pid_ = pid_;
9646         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
9647           to_bitField0_ |= 0x00000010;
9648         }
9649         result.success_ = success_;
9650         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
9651           to_bitField0_ |= 0x00000020;
9652         }
9653         result.negativeResponseCode_ = negativeResponseCode_;
9654         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
9655           to_bitField0_ |= 0x00000040;
9656         }
9657         result.payload_ = payload_;
9658         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
9659           to_bitField0_ |= 0x00000080;
9660         }
9661         result.value_ = value_;
9662         result.bitField0_ = to_bitField0_;
9663         onBuilt();
9664         return result;
9665       }
9666
9667       public Builder mergeFrom(com.google.protobuf.Message other) {
9668         if (other instanceof com.openxc.BinaryMessages.DiagnosticResponse) {
9669           return mergeFrom((com.openxc.BinaryMessages.DiagnosticResponse)other);
9670         } else {
9671           super.mergeFrom(other);
9672           return this;
9673         }
9674       }
9675
9676       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticResponse other) {
9677         if (other == com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance()) return this;
9678         if (other.hasBus()) {
9679           setBus(other.getBus());
9680         }
9681         if (other.hasMessageId()) {
9682           setMessageId(other.getMessageId());
9683         }
9684         if (other.hasMode()) {
9685           setMode(other.getMode());
9686         }
9687         if (other.hasPid()) {
9688           setPid(other.getPid());
9689         }
9690         if (other.hasSuccess()) {
9691           setSuccess(other.getSuccess());
9692         }
9693         if (other.hasNegativeResponseCode()) {
9694           setNegativeResponseCode(other.getNegativeResponseCode());
9695         }
9696         if (other.hasPayload()) {
9697           setPayload(other.getPayload());
9698         }
9699         if (other.hasValue()) {
9700           setValue(other.getValue());
9701         }
9702         this.mergeUnknownFields(other.getUnknownFields());
9703         return this;
9704       }
9705
9706       public final boolean isInitialized() {
9707         return true;
9708       }
9709
9710       public Builder mergeFrom(
9711           com.google.protobuf.CodedInputStream input,
9712           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9713           throws java.io.IOException {
9714         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
9715           com.google.protobuf.UnknownFieldSet.newBuilder(
9716             this.getUnknownFields());
9717         while (true) {
9718           int tag = input.readTag();
9719           switch (tag) {
9720             case 0:
9721               this.setUnknownFields(unknownFields.build());
9722               onChanged();
9723               return this;
9724             default: {
9725               if (!parseUnknownField(input, unknownFields,
9726                                      extensionRegistry, tag)) {
9727                 this.setUnknownFields(unknownFields.build());
9728                 onChanged();
9729                 return this;
9730               }
9731               break;
9732             }
9733             case 8: {
9734               bitField0_ |= 0x00000001;
9735               bus_ = input.readInt32();
9736               break;
9737             }
9738             case 16: {
9739               bitField0_ |= 0x00000002;
9740               messageId_ = input.readUInt32();
9741               break;
9742             }
9743             case 24: {
9744               bitField0_ |= 0x00000004;
9745               mode_ = input.readUInt32();
9746               break;
9747             }
9748             case 32: {
9749               bitField0_ |= 0x00000008;
9750               pid_ = input.readUInt32();
9751               break;
9752             }
9753             case 40: {
9754               bitField0_ |= 0x00000010;
9755               success_ = input.readBool();
9756               break;
9757             }
9758             case 48: {
9759               bitField0_ |= 0x00000020;
9760               negativeResponseCode_ = input.readUInt32();
9761               break;
9762             }
9763             case 58: {
9764               bitField0_ |= 0x00000040;
9765               payload_ = input.readBytes();
9766               break;
9767             }
9768             case 65: {
9769               bitField0_ |= 0x00000080;
9770               value_ = input.readDouble();
9771               break;
9772             }
9773           }
9774         }
9775       }
9776
9777       private int bitField0_;
9778
9779       // optional int32 bus = 1;
9780       private int bus_ ;
9781       public boolean hasBus() {
9782         return ((bitField0_ & 0x00000001) == 0x00000001);
9783       }
9784       public int getBus() {
9785         return bus_;
9786       }
9787       public Builder setBus(int value) {
9788         bitField0_ |= 0x00000001;
9789         bus_ = value;
9790         onChanged();
9791         return this;
9792       }
9793       public Builder clearBus() {
9794         bitField0_ = (bitField0_ & ~0x00000001);
9795         bus_ = 0;
9796         onChanged();
9797         return this;
9798       }
9799
9800       // optional uint32 message_id = 2;
9801       private int messageId_ ;
9802       public boolean hasMessageId() {
9803         return ((bitField0_ & 0x00000002) == 0x00000002);
9804       }
9805       public int getMessageId() {
9806         return messageId_;
9807       }
9808       public Builder setMessageId(int value) {
9809         bitField0_ |= 0x00000002;
9810         messageId_ = value;
9811         onChanged();
9812         return this;
9813       }
9814       public Builder clearMessageId() {
9815         bitField0_ = (bitField0_ & ~0x00000002);
9816         messageId_ = 0;
9817         onChanged();
9818         return this;
9819       }
9820
9821       // optional uint32 mode = 3;
9822       private int mode_ ;
9823       public boolean hasMode() {
9824         return ((bitField0_ & 0x00000004) == 0x00000004);
9825       }
9826       public int getMode() {
9827         return mode_;
9828       }
9829       public Builder setMode(int value) {
9830         bitField0_ |= 0x00000004;
9831         mode_ = value;
9832         onChanged();
9833         return this;
9834       }
9835       public Builder clearMode() {
9836         bitField0_ = (bitField0_ & ~0x00000004);
9837         mode_ = 0;
9838         onChanged();
9839         return this;
9840       }
9841
9842       // optional uint32 pid = 4;
9843       private int pid_ ;
9844       public boolean hasPid() {
9845         return ((bitField0_ & 0x00000008) == 0x00000008);
9846       }
9847       public int getPid() {
9848         return pid_;
9849       }
9850       public Builder setPid(int value) {
9851         bitField0_ |= 0x00000008;
9852         pid_ = value;
9853         onChanged();
9854         return this;
9855       }
9856       public Builder clearPid() {
9857         bitField0_ = (bitField0_ & ~0x00000008);
9858         pid_ = 0;
9859         onChanged();
9860         return this;
9861       }
9862
9863       // optional bool success = 5;
9864       private boolean success_ ;
9865       public boolean hasSuccess() {
9866         return ((bitField0_ & 0x00000010) == 0x00000010);
9867       }
9868       public boolean getSuccess() {
9869         return success_;
9870       }
9871       public Builder setSuccess(boolean value) {
9872         bitField0_ |= 0x00000010;
9873         success_ = value;
9874         onChanged();
9875         return this;
9876       }
9877       public Builder clearSuccess() {
9878         bitField0_ = (bitField0_ & ~0x00000010);
9879         success_ = false;
9880         onChanged();
9881         return this;
9882       }
9883
9884       // optional uint32 negative_response_code = 6;
9885       private int negativeResponseCode_ ;
9886       public boolean hasNegativeResponseCode() {
9887         return ((bitField0_ & 0x00000020) == 0x00000020);
9888       }
9889       public int getNegativeResponseCode() {
9890         return negativeResponseCode_;
9891       }
9892       public Builder setNegativeResponseCode(int value) {
9893         bitField0_ |= 0x00000020;
9894         negativeResponseCode_ = value;
9895         onChanged();
9896         return this;
9897       }
9898       public Builder clearNegativeResponseCode() {
9899         bitField0_ = (bitField0_ & ~0x00000020);
9900         negativeResponseCode_ = 0;
9901         onChanged();
9902         return this;
9903       }
9904
9905       // optional bytes payload = 7;
9906       private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY;
9907       public boolean hasPayload() {
9908         return ((bitField0_ & 0x00000040) == 0x00000040);
9909       }
9910       public com.google.protobuf.ByteString getPayload() {
9911         return payload_;
9912       }
9913       public Builder setPayload(com.google.protobuf.ByteString value) {
9914         if (value == null) {
9915     throw new NullPointerException();
9916   }
9917   bitField0_ |= 0x00000040;
9918         payload_ = value;
9919         onChanged();
9920         return this;
9921       }
9922       public Builder clearPayload() {
9923         bitField0_ = (bitField0_ & ~0x00000040);
9924         payload_ = getDefaultInstance().getPayload();
9925         onChanged();
9926         return this;
9927       }
9928
9929       // optional double value = 8;
9930       private double value_ ;
9931       public boolean hasValue() {
9932         return ((bitField0_ & 0x00000080) == 0x00000080);
9933       }
9934       public double getValue() {
9935         return value_;
9936       }
9937       public Builder setValue(double value) {
9938         bitField0_ |= 0x00000080;
9939         value_ = value;
9940         onChanged();
9941         return this;
9942       }
9943       public Builder clearValue() {
9944         bitField0_ = (bitField0_ & ~0x00000080);
9945         value_ = 0D;
9946         onChanged();
9947         return this;
9948       }
9949
9950       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticResponse)
9951     }
9952
9953     static {
9954       defaultInstance = new DiagnosticResponse(true);
9955       defaultInstance.initFields();
9956     }
9957
9958     // @@protoc_insertion_point(class_scope:openxc.DiagnosticResponse)
9959   }
9960
9961   public interface DynamicFieldOrBuilder
9962       extends com.google.protobuf.MessageOrBuilder {
9963
9964     // optional .openxc.DynamicField.Type type = 1;
9965     boolean hasType();
9966     com.openxc.BinaryMessages.DynamicField.Type getType();
9967
9968     // optional string string_value = 2;
9969     boolean hasStringValue();
9970     String getStringValue();
9971
9972     // optional double numeric_value = 3;
9973     boolean hasNumericValue();
9974     double getNumericValue();
9975
9976     // optional bool boolean_value = 4;
9977     boolean hasBooleanValue();
9978     boolean getBooleanValue();
9979   }
9980   public static final class DynamicField extends
9981       com.google.protobuf.GeneratedMessage
9982       implements DynamicFieldOrBuilder {
9983     // Use DynamicField.newBuilder() to construct.
9984     private DynamicField(Builder builder) {
9985       super(builder);
9986     }
9987     private DynamicField(boolean noInit) {}
9988
9989     private static final DynamicField defaultInstance;
9990     public static DynamicField getDefaultInstance() {
9991       return defaultInstance;
9992     }
9993
9994     public DynamicField getDefaultInstanceForType() {
9995       return defaultInstance;
9996     }
9997
9998     public static final com.google.protobuf.Descriptors.Descriptor
9999         getDescriptor() {
10000       return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
10001     }
10002
10003     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
10004         internalGetFieldAccessorTable() {
10005       return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_fieldAccessorTable;
10006     }
10007
10008     public enum Type
10009         implements com.google.protobuf.ProtocolMessageEnum {
10010       STRING(0, 1),
10011       NUM(1, 2),
10012       BOOL(2, 3),
10013       ;
10014
10015       public static final int STRING_VALUE = 1;
10016       public static final int NUM_VALUE = 2;
10017       public static final int BOOL_VALUE = 3;
10018
10019
10020       public final int getNumber() { return value; }
10021
10022       public static Type valueOf(int value) {
10023         switch (value) {
10024           case 1: return STRING;
10025           case 2: return NUM;
10026           case 3: return BOOL;
10027           default: return null;
10028         }
10029       }
10030
10031       public static com.google.protobuf.Internal.EnumLiteMap<Type>
10032           internalGetValueMap() {
10033         return internalValueMap;
10034       }
10035       private static com.google.protobuf.Internal.EnumLiteMap<Type>
10036           internalValueMap =
10037             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
10038               public Type findValueByNumber(int number) {
10039                 return Type.valueOf(number);
10040               }
10041             };
10042
10043       public final com.google.protobuf.Descriptors.EnumValueDescriptor
10044           getValueDescriptor() {
10045         return getDescriptor().getValues().get(index);
10046       }
10047       public final com.google.protobuf.Descriptors.EnumDescriptor
10048           getDescriptorForType() {
10049         return getDescriptor();
10050       }
10051       public static final com.google.protobuf.Descriptors.EnumDescriptor
10052           getDescriptor() {
10053         return com.openxc.BinaryMessages.DynamicField.getDescriptor().getEnumTypes().get(0);
10054       }
10055
10056       private static final Type[] VALUES = {
10057         STRING, NUM, BOOL,
10058       };
10059
10060       public static Type valueOf(
10061           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
10062         if (desc.getType() != getDescriptor()) {
10063           throw new java.lang.IllegalArgumentException(
10064             "EnumValueDescriptor is not for this type.");
10065         }
10066         return VALUES[desc.getIndex()];
10067       }
10068
10069       private final int index;
10070       private final int value;
10071
10072       private Type(int index, int value) {
10073         this.index = index;
10074         this.value = value;
10075       }
10076
10077       // @@protoc_insertion_point(enum_scope:openxc.DynamicField.Type)
10078     }
10079
10080     private int bitField0_;
10081     // optional .openxc.DynamicField.Type type = 1;
10082     public static final int TYPE_FIELD_NUMBER = 1;
10083     private com.openxc.BinaryMessages.DynamicField.Type type_;
10084     public boolean hasType() {
10085       return ((bitField0_ & 0x00000001) == 0x00000001);
10086     }
10087     public com.openxc.BinaryMessages.DynamicField.Type getType() {
10088       return type_;
10089     }
10090
10091     // optional string string_value = 2;
10092     public static final int STRING_VALUE_FIELD_NUMBER = 2;
10093     private java.lang.Object stringValue_;
10094     public boolean hasStringValue() {
10095       return ((bitField0_ & 0x00000002) == 0x00000002);
10096     }
10097     public String getStringValue() {
10098       java.lang.Object ref = stringValue_;
10099       if (ref instanceof String) {
10100         return (String) ref;
10101       } else {
10102         com.google.protobuf.ByteString bs =
10103             (com.google.protobuf.ByteString) ref;
10104         String s = bs.toStringUtf8();
10105         if (com.google.protobuf.Internal.isValidUtf8(bs)) {
10106           stringValue_ = s;
10107         }
10108         return s;
10109       }
10110     }
10111     private com.google.protobuf.ByteString getStringValueBytes() {
10112       java.lang.Object ref = stringValue_;
10113       if (ref instanceof String) {
10114         com.google.protobuf.ByteString b =
10115             com.google.protobuf.ByteString.copyFromUtf8((String) ref);
10116         stringValue_ = b;
10117         return b;
10118       } else {
10119         return (com.google.protobuf.ByteString) ref;
10120       }
10121     }
10122
10123     // optional double numeric_value = 3;
10124     public static final int NUMERIC_VALUE_FIELD_NUMBER = 3;
10125     private double numericValue_;
10126     public boolean hasNumericValue() {
10127       return ((bitField0_ & 0x00000004) == 0x00000004);
10128     }
10129     public double getNumericValue() {
10130       return numericValue_;
10131     }
10132
10133     // optional bool boolean_value = 4;
10134     public static final int BOOLEAN_VALUE_FIELD_NUMBER = 4;
10135     private boolean booleanValue_;
10136     public boolean hasBooleanValue() {
10137       return ((bitField0_ & 0x00000008) == 0x00000008);
10138     }
10139     public boolean getBooleanValue() {
10140       return booleanValue_;
10141     }
10142
10143     private void initFields() {
10144       type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
10145       stringValue_ = "";
10146       numericValue_ = 0D;
10147       booleanValue_ = false;
10148     }
10149     private byte memoizedIsInitialized = -1;
10150     public final boolean isInitialized() {
10151       byte isInitialized = memoizedIsInitialized;
10152       if (isInitialized != -1) return isInitialized == 1;
10153
10154       memoizedIsInitialized = 1;
10155       return true;
10156     }
10157
10158     public void writeTo(com.google.protobuf.CodedOutputStream output)
10159                         throws java.io.IOException {
10160       getSerializedSize();
10161       if (((bitField0_ & 0x00000001) == 0x00000001)) {
10162         output.writeEnum(1, type_.getNumber());
10163       }
10164       if (((bitField0_ & 0x00000002) == 0x00000002)) {
10165         output.writeBytes(2, getStringValueBytes());
10166       }
10167       if (((bitField0_ & 0x00000004) == 0x00000004)) {
10168         output.writeDouble(3, numericValue_);
10169       }
10170       if (((bitField0_ & 0x00000008) == 0x00000008)) {
10171         output.writeBool(4, booleanValue_);
10172       }
10173       getUnknownFields().writeTo(output);
10174     }
10175
10176     private int memoizedSerializedSize = -1;
10177     public int getSerializedSize() {
10178       int size = memoizedSerializedSize;
10179       if (size != -1) return size;
10180
10181       size = 0;
10182       if (((bitField0_ & 0x00000001) == 0x00000001)) {
10183         size += com.google.protobuf.CodedOutputStream
10184           .computeEnumSize(1, type_.getNumber());
10185       }
10186       if (((bitField0_ & 0x00000002) == 0x00000002)) {
10187         size += com.google.protobuf.CodedOutputStream
10188           .computeBytesSize(2, getStringValueBytes());
10189       }
10190       if (((bitField0_ & 0x00000004) == 0x00000004)) {
10191         size += com.google.protobuf.CodedOutputStream
10192           .computeDoubleSize(3, numericValue_);
10193       }
10194       if (((bitField0_ & 0x00000008) == 0x00000008)) {
10195         size += com.google.protobuf.CodedOutputStream
10196           .computeBoolSize(4, booleanValue_);
10197       }
10198       size += getUnknownFields().getSerializedSize();
10199       memoizedSerializedSize = size;
10200       return size;
10201     }
10202
10203     private static final long serialVersionUID = 0L;
10204     @java.lang.Override
10205     protected java.lang.Object writeReplace()
10206         throws java.io.ObjectStreamException {
10207       return super.writeReplace();
10208     }
10209
10210     public static com.openxc.BinaryMessages.DynamicField parseFrom(
10211         com.google.protobuf.ByteString data)
10212         throws com.google.protobuf.InvalidProtocolBufferException {
10213       return newBuilder().mergeFrom(data).buildParsed();
10214     }
10215     public static com.openxc.BinaryMessages.DynamicField parseFrom(
10216         com.google.protobuf.ByteString data,
10217         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10218         throws com.google.protobuf.InvalidProtocolBufferException {
10219       return newBuilder().mergeFrom(data, extensionRegistry)
10220                .buildParsed();
10221     }
10222     public static com.openxc.BinaryMessages.DynamicField parseFrom(byte[] data)
10223         throws com.google.protobuf.InvalidProtocolBufferException {
10224       return newBuilder().mergeFrom(data).buildParsed();
10225     }
10226     public static com.openxc.BinaryMessages.DynamicField parseFrom(
10227         byte[] data,
10228         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10229         throws com.google.protobuf.InvalidProtocolBufferException {
10230       return newBuilder().mergeFrom(data, extensionRegistry)
10231                .buildParsed();
10232     }
10233     public static com.openxc.BinaryMessages.DynamicField parseFrom(java.io.InputStream input)
10234         throws java.io.IOException {
10235       return newBuilder().mergeFrom(input).buildParsed();
10236     }
10237     public static com.openxc.BinaryMessages.DynamicField parseFrom(
10238         java.io.InputStream input,
10239         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10240         throws java.io.IOException {
10241       return newBuilder().mergeFrom(input, extensionRegistry)
10242                .buildParsed();
10243     }
10244     public static com.openxc.BinaryMessages.DynamicField parseDelimitedFrom(java.io.InputStream input)
10245         throws java.io.IOException {
10246       Builder builder = newBuilder();
10247       if (builder.mergeDelimitedFrom(input)) {
10248         return builder.buildParsed();
10249       } else {
10250         return null;
10251       }
10252     }
10253     public static com.openxc.BinaryMessages.DynamicField parseDelimitedFrom(
10254         java.io.InputStream input,
10255         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10256         throws java.io.IOException {
10257       Builder builder = newBuilder();
10258       if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
10259         return builder.buildParsed();
10260       } else {
10261         return null;
10262       }
10263     }
10264     public static com.openxc.BinaryMessages.DynamicField parseFrom(
10265         com.google.protobuf.CodedInputStream input)
10266         throws java.io.IOException {
10267       return newBuilder().mergeFrom(input).buildParsed();
10268     }
10269     public static com.openxc.BinaryMessages.DynamicField parseFrom(
10270         com.google.protobuf.CodedInputStream input,
10271         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10272         throws java.io.IOException {
10273       return newBuilder().mergeFrom(input, extensionRegistry)
10274                .buildParsed();
10275     }
10276
10277     public static Builder newBuilder() { return Builder.create(); }
10278     public Builder newBuilderForType() { return newBuilder(); }
10279     public static Builder newBuilder(com.openxc.BinaryMessages.DynamicField prototype) {
10280       return newBuilder().mergeFrom(prototype);
10281     }
10282     public Builder toBuilder() { return newBuilder(this); }
10283
10284     @java.lang.Override
10285     protected Builder newBuilderForType(
10286         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
10287       Builder builder = new Builder(parent);
10288       return builder;
10289     }
10290     public static final class Builder extends
10291         com.google.protobuf.GeneratedMessage.Builder<Builder>
10292        implements com.openxc.BinaryMessages.DynamicFieldOrBuilder {
10293       public static final com.google.protobuf.Descriptors.Descriptor
10294           getDescriptor() {
10295         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
10296       }
10297
10298       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
10299           internalGetFieldAccessorTable() {
10300         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_fieldAccessorTable;
10301       }
10302
10303       // Construct using com.openxc.BinaryMessages.DynamicField.newBuilder()
10304       private Builder() {
10305         maybeForceBuilderInitialization();
10306       }
10307
10308       private Builder(BuilderParent parent) {
10309         super(parent);
10310         maybeForceBuilderInitialization();
10311       }
10312       private void maybeForceBuilderInitialization() {
10313         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
10314         }
10315       }
10316       private static Builder create() {
10317         return new Builder();
10318       }
10319
10320       public Builder clear() {
10321         super.clear();
10322         type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
10323         bitField0_ = (bitField0_ & ~0x00000001);
10324         stringValue_ = "";
10325         bitField0_ = (bitField0_ & ~0x00000002);
10326         numericValue_ = 0D;
10327         bitField0_ = (bitField0_ & ~0x00000004);
10328         booleanValue_ = false;
10329         bitField0_ = (bitField0_ & ~0x00000008);
10330         return this;
10331       }
10332
10333       public Builder clone() {
10334         return create().mergeFrom(buildPartial());
10335       }
10336
10337       public com.google.protobuf.Descriptors.Descriptor
10338           getDescriptorForType() {
10339         return com.openxc.BinaryMessages.DynamicField.getDescriptor();
10340       }
10341
10342       public com.openxc.BinaryMessages.DynamicField getDefaultInstanceForType() {
10343         return com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
10344       }
10345
10346       public com.openxc.BinaryMessages.DynamicField build() {
10347         com.openxc.BinaryMessages.DynamicField result = buildPartial();
10348         if (!result.isInitialized()) {
10349           throw newUninitializedMessageException(result);
10350         }
10351         return result;
10352       }
10353
10354       private com.openxc.BinaryMessages.DynamicField buildParsed()
10355           throws com.google.protobuf.InvalidProtocolBufferException {
10356         com.openxc.BinaryMessages.DynamicField result = buildPartial();
10357         if (!result.isInitialized()) {
10358           throw newUninitializedMessageException(
10359             result).asInvalidProtocolBufferException();
10360         }
10361         return result;
10362       }
10363
10364       public com.openxc.BinaryMessages.DynamicField buildPartial() {
10365         com.openxc.BinaryMessages.DynamicField result = new com.openxc.BinaryMessages.DynamicField(this);
10366         int from_bitField0_ = bitField0_;
10367         int to_bitField0_ = 0;
10368         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
10369           to_bitField0_ |= 0x00000001;
10370         }
10371         result.type_ = type_;
10372         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
10373           to_bitField0_ |= 0x00000002;
10374         }
10375         result.stringValue_ = stringValue_;
10376         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
10377           to_bitField0_ |= 0x00000004;
10378         }
10379         result.numericValue_ = numericValue_;
10380         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
10381           to_bitField0_ |= 0x00000008;
10382         }
10383         result.booleanValue_ = booleanValue_;
10384         result.bitField0_ = to_bitField0_;
10385         onBuilt();
10386         return result;
10387       }
10388
10389       public Builder mergeFrom(com.google.protobuf.Message other) {
10390         if (other instanceof com.openxc.BinaryMessages.DynamicField) {
10391           return mergeFrom((com.openxc.BinaryMessages.DynamicField)other);
10392         } else {
10393           super.mergeFrom(other);
10394           return this;
10395         }
10396       }
10397
10398       public Builder mergeFrom(com.openxc.BinaryMessages.DynamicField other) {
10399         if (other == com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) return this;
10400         if (other.hasType()) {
10401           setType(other.getType());
10402         }
10403         if (other.hasStringValue()) {
10404           setStringValue(other.getStringValue());
10405         }
10406         if (other.hasNumericValue()) {
10407           setNumericValue(other.getNumericValue());
10408         }
10409         if (other.hasBooleanValue()) {
10410           setBooleanValue(other.getBooleanValue());
10411         }
10412         this.mergeUnknownFields(other.getUnknownFields());
10413         return this;
10414       }
10415
10416       public final boolean isInitialized() {
10417         return true;
10418       }
10419
10420       public Builder mergeFrom(
10421           com.google.protobuf.CodedInputStream input,
10422           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10423           throws java.io.IOException {
10424         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
10425           com.google.protobuf.UnknownFieldSet.newBuilder(
10426             this.getUnknownFields());
10427         while (true) {
10428           int tag = input.readTag();
10429           switch (tag) {
10430             case 0:
10431               this.setUnknownFields(unknownFields.build());
10432               onChanged();
10433               return this;
10434             default: {
10435               if (!parseUnknownField(input, unknownFields,
10436                                      extensionRegistry, tag)) {
10437                 this.setUnknownFields(unknownFields.build());
10438                 onChanged();
10439                 return this;
10440               }
10441               break;
10442             }
10443             case 8: {
10444               int rawValue = input.readEnum();
10445               com.openxc.BinaryMessages.DynamicField.Type value = com.openxc.BinaryMessages.DynamicField.Type.valueOf(rawValue);
10446               if (value == null) {
10447                 unknownFields.mergeVarintField(1, rawValue);
10448               } else {
10449                 bitField0_ |= 0x00000001;
10450                 type_ = value;
10451               }
10452               break;
10453             }
10454             case 18: {
10455               bitField0_ |= 0x00000002;
10456               stringValue_ = input.readBytes();
10457               break;
10458             }
10459             case 25: {
10460               bitField0_ |= 0x00000004;
10461               numericValue_ = input.readDouble();
10462               break;
10463             }
10464             case 32: {
10465               bitField0_ |= 0x00000008;
10466               booleanValue_ = input.readBool();
10467               break;
10468             }
10469           }
10470         }
10471       }
10472
10473       private int bitField0_;
10474
10475       // optional .openxc.DynamicField.Type type = 1;
10476       private com.openxc.BinaryMessages.DynamicField.Type type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
10477       public boolean hasType() {
10478         return ((bitField0_ & 0x00000001) == 0x00000001);
10479       }
10480       public com.openxc.BinaryMessages.DynamicField.Type getType() {
10481         return type_;
10482       }
10483       public Builder setType(com.openxc.BinaryMessages.DynamicField.Type value) {
10484         if (value == null) {
10485           throw new NullPointerException();
10486         }
10487         bitField0_ |= 0x00000001;
10488         type_ = value;
10489         onChanged();
10490         return this;
10491       }
10492       public Builder clearType() {
10493         bitField0_ = (bitField0_ & ~0x00000001);
10494         type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
10495         onChanged();
10496         return this;
10497       }
10498
10499       // optional string string_value = 2;
10500       private java.lang.Object stringValue_ = "";
10501       public boolean hasStringValue() {
10502         return ((bitField0_ & 0x00000002) == 0x00000002);
10503       }
10504       public String getStringValue() {
10505         java.lang.Object ref = stringValue_;
10506         if (!(ref instanceof String)) {
10507           String s = ((com.google.protobuf.ByteString) ref).toStringUtf8();
10508           stringValue_ = s;
10509           return s;
10510         } else {
10511           return (String) ref;
10512         }
10513       }
10514       public Builder setStringValue(String value) {
10515         if (value == null) {
10516     throw new NullPointerException();
10517   }
10518   bitField0_ |= 0x00000002;
10519         stringValue_ = value;
10520         onChanged();
10521         return this;
10522       }
10523       public Builder clearStringValue() {
10524         bitField0_ = (bitField0_ & ~0x00000002);
10525         stringValue_ = getDefaultInstance().getStringValue();
10526         onChanged();
10527         return this;
10528       }
10529       void setStringValue(com.google.protobuf.ByteString value) {
10530         bitField0_ |= 0x00000002;
10531         stringValue_ = value;
10532         onChanged();
10533       }
10534
10535       // optional double numeric_value = 3;
10536       private double numericValue_ ;
10537       public boolean hasNumericValue() {
10538         return ((bitField0_ & 0x00000004) == 0x00000004);
10539       }
10540       public double getNumericValue() {
10541         return numericValue_;
10542       }
10543       public Builder setNumericValue(double value) {
10544         bitField0_ |= 0x00000004;
10545         numericValue_ = value;
10546         onChanged();
10547         return this;
10548       }
10549       public Builder clearNumericValue() {
10550         bitField0_ = (bitField0_ & ~0x00000004);
10551         numericValue_ = 0D;
10552         onChanged();
10553         return this;
10554       }
10555
10556       // optional bool boolean_value = 4;
10557       private boolean booleanValue_ ;
10558       public boolean hasBooleanValue() {
10559         return ((bitField0_ & 0x00000008) == 0x00000008);
10560       }
10561       public boolean getBooleanValue() {
10562         return booleanValue_;
10563       }
10564       public Builder setBooleanValue(boolean value) {
10565         bitField0_ |= 0x00000008;
10566         booleanValue_ = value;
10567         onChanged();
10568         return this;
10569       }
10570       public Builder clearBooleanValue() {
10571         bitField0_ = (bitField0_ & ~0x00000008);
10572         booleanValue_ = false;
10573         onChanged();
10574         return this;
10575       }
10576
10577       // @@protoc_insertion_point(builder_scope:openxc.DynamicField)
10578     }
10579
10580     static {
10581       defaultInstance = new DynamicField(true);
10582       defaultInstance.initFields();
10583     }
10584
10585     // @@protoc_insertion_point(class_scope:openxc.DynamicField)
10586   }
10587
10588   public interface SimpleMessageOrBuilder
10589       extends com.google.protobuf.MessageOrBuilder {
10590
10591     // optional string name = 1;
10592     boolean hasName();
10593     String getName();
10594
10595     // optional .openxc.DynamicField value = 2;
10596     boolean hasValue();
10597     com.openxc.BinaryMessages.DynamicField getValue();
10598     com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder();
10599
10600     // optional .openxc.DynamicField event = 3;
10601     boolean hasEvent();
10602     com.openxc.BinaryMessages.DynamicField getEvent();
10603     com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder();
10604   }
10605   public static final class SimpleMessage extends
10606       com.google.protobuf.GeneratedMessage
10607       implements SimpleMessageOrBuilder {
10608     // Use SimpleMessage.newBuilder() to construct.
10609     private SimpleMessage(Builder builder) {
10610       super(builder);
10611     }
10612     private SimpleMessage(boolean noInit) {}
10613
10614     private static final SimpleMessage defaultInstance;
10615     public static SimpleMessage getDefaultInstance() {
10616       return defaultInstance;
10617     }
10618
10619     public SimpleMessage getDefaultInstanceForType() {
10620       return defaultInstance;
10621     }
10622
10623     public static final com.google.protobuf.Descriptors.Descriptor
10624         getDescriptor() {
10625       return com.openxc.BinaryMessages.internal_static_openxc_SimpleMessage_descriptor;
10626     }
10627
10628     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
10629         internalGetFieldAccessorTable() {
10630       return com.openxc.BinaryMessages.internal_static_openxc_SimpleMessage_fieldAccessorTable;
10631     }
10632
10633     private int bitField0_;
10634     // optional string name = 1;
10635     public static final int NAME_FIELD_NUMBER = 1;
10636     private java.lang.Object name_;
10637     public boolean hasName() {
10638       return ((bitField0_ & 0x00000001) == 0x00000001);
10639     }
10640     public String getName() {
10641       java.lang.Object ref = name_;
10642       if (ref instanceof String) {
10643         return (String) ref;
10644       } else {
10645         com.google.protobuf.ByteString bs =
10646             (com.google.protobuf.ByteString) ref;
10647         String s = bs.toStringUtf8();
10648         if (com.google.protobuf.Internal.isValidUtf8(bs)) {
10649           name_ = s;
10650         }
10651         return s;
10652       }
10653     }
10654     private com.google.protobuf.ByteString getNameBytes() {
10655       java.lang.Object ref = name_;
10656       if (ref instanceof String) {
10657         com.google.protobuf.ByteString b =
10658             com.google.protobuf.ByteString.copyFromUtf8((String) ref);
10659         name_ = b;
10660         return b;
10661       } else {
10662         return (com.google.protobuf.ByteString) ref;
10663       }
10664     }
10665
10666     // optional .openxc.DynamicField value = 2;
10667     public static final int VALUE_FIELD_NUMBER = 2;
10668     private com.openxc.BinaryMessages.DynamicField value_;
10669     public boolean hasValue() {
10670       return ((bitField0_ & 0x00000002) == 0x00000002);
10671     }
10672     public com.openxc.BinaryMessages.DynamicField getValue() {
10673       return value_;
10674     }
10675     public com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder() {
10676       return value_;
10677     }
10678
10679     // optional .openxc.DynamicField event = 3;
10680     public static final int EVENT_FIELD_NUMBER = 3;
10681     private com.openxc.BinaryMessages.DynamicField event_;
10682     public boolean hasEvent() {
10683       return ((bitField0_ & 0x00000004) == 0x00000004);
10684     }
10685     public com.openxc.BinaryMessages.DynamicField getEvent() {
10686       return event_;
10687     }
10688     public com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder() {
10689       return event_;
10690     }
10691
10692     private void initFields() {
10693       name_ = "";
10694       value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
10695       event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
10696     }
10697     private byte memoizedIsInitialized = -1;
10698     public final boolean isInitialized() {
10699       byte isInitialized = memoizedIsInitialized;
10700       if (isInitialized != -1) return isInitialized == 1;
10701
10702       memoizedIsInitialized = 1;
10703       return true;
10704     }
10705
10706     public void writeTo(com.google.protobuf.CodedOutputStream output)
10707                         throws java.io.IOException {
10708       getSerializedSize();
10709       if (((bitField0_ & 0x00000001) == 0x00000001)) {
10710         output.writeBytes(1, getNameBytes());
10711       }
10712       if (((bitField0_ & 0x00000002) == 0x00000002)) {
10713         output.writeMessage(2, value_);
10714       }
10715       if (((bitField0_ & 0x00000004) == 0x00000004)) {
10716         output.writeMessage(3, event_);
10717       }
10718       getUnknownFields().writeTo(output);
10719     }
10720
10721     private int memoizedSerializedSize = -1;
10722     public int getSerializedSize() {
10723       int size = memoizedSerializedSize;
10724       if (size != -1) return size;
10725
10726       size = 0;
10727       if (((bitField0_ & 0x00000001) == 0x00000001)) {
10728         size += com.google.protobuf.CodedOutputStream
10729           .computeBytesSize(1, getNameBytes());
10730       }
10731       if (((bitField0_ & 0x00000002) == 0x00000002)) {
10732         size += com.google.protobuf.CodedOutputStream
10733           .computeMessageSize(2, value_);
10734       }
10735       if (((bitField0_ & 0x00000004) == 0x00000004)) {
10736         size += com.google.protobuf.CodedOutputStream
10737           .computeMessageSize(3, event_);
10738       }
10739       size += getUnknownFields().getSerializedSize();
10740       memoizedSerializedSize = size;
10741       return size;
10742     }
10743
10744     private static final long serialVersionUID = 0L;
10745     @java.lang.Override
10746     protected java.lang.Object writeReplace()
10747         throws java.io.ObjectStreamException {
10748       return super.writeReplace();
10749     }
10750
10751     public static com.openxc.BinaryMessages.SimpleMessage parseFrom(
10752         com.google.protobuf.ByteString data)
10753         throws com.google.protobuf.InvalidProtocolBufferException {
10754       return newBuilder().mergeFrom(data).buildParsed();
10755     }
10756     public static com.openxc.BinaryMessages.SimpleMessage parseFrom(
10757         com.google.protobuf.ByteString data,
10758         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10759         throws com.google.protobuf.InvalidProtocolBufferException {
10760       return newBuilder().mergeFrom(data, extensionRegistry)
10761                .buildParsed();
10762     }
10763     public static com.openxc.BinaryMessages.SimpleMessage parseFrom(byte[] data)
10764         throws com.google.protobuf.InvalidProtocolBufferException {
10765       return newBuilder().mergeFrom(data).buildParsed();
10766     }
10767     public static com.openxc.BinaryMessages.SimpleMessage parseFrom(
10768         byte[] data,
10769         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10770         throws com.google.protobuf.InvalidProtocolBufferException {
10771       return newBuilder().mergeFrom(data, extensionRegistry)
10772                .buildParsed();
10773     }
10774     public static com.openxc.BinaryMessages.SimpleMessage parseFrom(java.io.InputStream input)
10775         throws java.io.IOException {
10776       return newBuilder().mergeFrom(input).buildParsed();
10777     }
10778     public static com.openxc.BinaryMessages.SimpleMessage parseFrom(
10779         java.io.InputStream input,
10780         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10781         throws java.io.IOException {
10782       return newBuilder().mergeFrom(input, extensionRegistry)
10783                .buildParsed();
10784     }
10785     public static com.openxc.BinaryMessages.SimpleMessage parseDelimitedFrom(java.io.InputStream input)
10786         throws java.io.IOException {
10787       Builder builder = newBuilder();
10788       if (builder.mergeDelimitedFrom(input)) {
10789         return builder.buildParsed();
10790       } else {
10791         return null;
10792       }
10793     }
10794     public static com.openxc.BinaryMessages.SimpleMessage parseDelimitedFrom(
10795         java.io.InputStream input,
10796         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10797         throws java.io.IOException {
10798       Builder builder = newBuilder();
10799       if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
10800         return builder.buildParsed();
10801       } else {
10802         return null;
10803       }
10804     }
10805     public static com.openxc.BinaryMessages.SimpleMessage parseFrom(
10806         com.google.protobuf.CodedInputStream input)
10807         throws java.io.IOException {
10808       return newBuilder().mergeFrom(input).buildParsed();
10809     }
10810     public static com.openxc.BinaryMessages.SimpleMessage parseFrom(
10811         com.google.protobuf.CodedInputStream input,
10812         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10813         throws java.io.IOException {
10814       return newBuilder().mergeFrom(input, extensionRegistry)
10815                .buildParsed();
10816     }
10817
10818     public static Builder newBuilder() { return Builder.create(); }
10819     public Builder newBuilderForType() { return newBuilder(); }
10820     public static Builder newBuilder(com.openxc.BinaryMessages.SimpleMessage prototype) {
10821       return newBuilder().mergeFrom(prototype);
10822     }
10823     public Builder toBuilder() { return newBuilder(this); }
10824
10825     @java.lang.Override
10826     protected Builder newBuilderForType(
10827         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
10828       Builder builder = new Builder(parent);
10829       return builder;
10830     }
10831     public static final class Builder extends
10832         com.google.protobuf.GeneratedMessage.Builder<Builder>
10833        implements com.openxc.BinaryMessages.SimpleMessageOrBuilder {
10834       public static final com.google.protobuf.Descriptors.Descriptor
10835           getDescriptor() {
10836         return com.openxc.BinaryMessages.internal_static_openxc_SimpleMessage_descriptor;
10837       }
10838
10839       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
10840           internalGetFieldAccessorTable() {
10841         return com.openxc.BinaryMessages.internal_static_openxc_SimpleMessage_fieldAccessorTable;
10842       }
10843
10844       // Construct using com.openxc.BinaryMessages.SimpleMessage.newBuilder()
10845       private Builder() {
10846         maybeForceBuilderInitialization();
10847       }
10848
10849       private Builder(BuilderParent parent) {
10850         super(parent);
10851         maybeForceBuilderInitialization();
10852       }
10853       private void maybeForceBuilderInitialization() {
10854         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
10855           getValueFieldBuilder();
10856           getEventFieldBuilder();
10857         }
10858       }
10859       private static Builder create() {
10860         return new Builder();
10861       }
10862
10863       public Builder clear() {
10864         super.clear();
10865         name_ = "";
10866         bitField0_ = (bitField0_ & ~0x00000001);
10867         if (valueBuilder_ == null) {
10868           value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
10869         } else {
10870           valueBuilder_.clear();
10871         }
10872         bitField0_ = (bitField0_ & ~0x00000002);
10873         if (eventBuilder_ == null) {
10874           event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
10875         } else {
10876           eventBuilder_.clear();
10877         }
10878         bitField0_ = (bitField0_ & ~0x00000004);
10879         return this;
10880       }
10881
10882       public Builder clone() {
10883         return create().mergeFrom(buildPartial());
10884       }
10885
10886       public com.google.protobuf.Descriptors.Descriptor
10887           getDescriptorForType() {
10888         return com.openxc.BinaryMessages.SimpleMessage.getDescriptor();
10889       }
10890
10891       public com.openxc.BinaryMessages.SimpleMessage getDefaultInstanceForType() {
10892         return com.openxc.BinaryMessages.SimpleMessage.getDefaultInstance();
10893       }
10894
10895       public com.openxc.BinaryMessages.SimpleMessage build() {
10896         com.openxc.BinaryMessages.SimpleMessage result = buildPartial();
10897         if (!result.isInitialized()) {
10898           throw newUninitializedMessageException(result);
10899         }
10900         return result;
10901       }
10902
10903       private com.openxc.BinaryMessages.SimpleMessage buildParsed()
10904           throws com.google.protobuf.InvalidProtocolBufferException {
10905         com.openxc.BinaryMessages.SimpleMessage result = buildPartial();
10906         if (!result.isInitialized()) {
10907           throw newUninitializedMessageException(
10908             result).asInvalidProtocolBufferException();
10909         }
10910         return result;
10911       }
10912
10913       public com.openxc.BinaryMessages.SimpleMessage buildPartial() {
10914         com.openxc.BinaryMessages.SimpleMessage result = new com.openxc.BinaryMessages.SimpleMessage(this);
10915         int from_bitField0_ = bitField0_;
10916         int to_bitField0_ = 0;
10917         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
10918           to_bitField0_ |= 0x00000001;
10919         }
10920         result.name_ = name_;
10921         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
10922           to_bitField0_ |= 0x00000002;
10923         }
10924         if (valueBuilder_ == null) {
10925           result.value_ = value_;
10926         } else {
10927           result.value_ = valueBuilder_.build();
10928         }
10929         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
10930           to_bitField0_ |= 0x00000004;
10931         }
10932         if (eventBuilder_ == null) {
10933           result.event_ = event_;
10934         } else {
10935           result.event_ = eventBuilder_.build();
10936         }
10937         result.bitField0_ = to_bitField0_;
10938         onBuilt();
10939         return result;
10940       }
10941
10942       public Builder mergeFrom(com.google.protobuf.Message other) {
10943         if (other instanceof com.openxc.BinaryMessages.SimpleMessage) {
10944           return mergeFrom((com.openxc.BinaryMessages.SimpleMessage)other);
10945         } else {
10946           super.mergeFrom(other);
10947           return this;
10948         }
10949       }
10950
10951       public Builder mergeFrom(com.openxc.BinaryMessages.SimpleMessage other) {
10952         if (other == com.openxc.BinaryMessages.SimpleMessage.getDefaultInstance()) return this;
10953         if (other.hasName()) {
10954           setName(other.getName());
10955         }
10956         if (other.hasValue()) {
10957           mergeValue(other.getValue());
10958         }
10959         if (other.hasEvent()) {
10960           mergeEvent(other.getEvent());
10961         }
10962         this.mergeUnknownFields(other.getUnknownFields());
10963         return this;
10964       }
10965
10966       public final boolean isInitialized() {
10967         return true;
10968       }
10969
10970       public Builder mergeFrom(
10971           com.google.protobuf.CodedInputStream input,
10972           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10973           throws java.io.IOException {
10974         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
10975           com.google.protobuf.UnknownFieldSet.newBuilder(
10976             this.getUnknownFields());
10977         while (true) {
10978           int tag = input.readTag();
10979           switch (tag) {
10980             case 0:
10981               this.setUnknownFields(unknownFields.build());
10982               onChanged();
10983               return this;
10984             default: {
10985               if (!parseUnknownField(input, unknownFields,
10986                                      extensionRegistry, tag)) {
10987                 this.setUnknownFields(unknownFields.build());
10988                 onChanged();
10989                 return this;
10990               }
10991               break;
10992             }
10993             case 10: {
10994               bitField0_ |= 0x00000001;
10995               name_ = input.readBytes();
10996               break;
10997             }
10998             case 18: {
10999               com.openxc.BinaryMessages.DynamicField.Builder subBuilder = com.openxc.BinaryMessages.DynamicField.newBuilder();
11000               if (hasValue()) {
11001                 subBuilder.mergeFrom(getValue());
11002               }
11003               input.readMessage(subBuilder, extensionRegistry);
11004               setValue(subBuilder.buildPartial());
11005               break;
11006             }
11007             case 26: {
11008               com.openxc.BinaryMessages.DynamicField.Builder subBuilder = com.openxc.BinaryMessages.DynamicField.newBuilder();
11009               if (hasEvent()) {
11010                 subBuilder.mergeFrom(getEvent());
11011               }
11012               input.readMessage(subBuilder, extensionRegistry);
11013               setEvent(subBuilder.buildPartial());
11014               break;
11015             }
11016           }
11017         }
11018       }
11019
11020       private int bitField0_;
11021
11022       // optional string name = 1;
11023       private java.lang.Object name_ = "";
11024       public boolean hasName() {
11025         return ((bitField0_ & 0x00000001) == 0x00000001);
11026       }
11027       public String getName() {
11028         java.lang.Object ref = name_;
11029         if (!(ref instanceof String)) {
11030           String s = ((com.google.protobuf.ByteString) ref).toStringUtf8();
11031           name_ = s;
11032           return s;
11033         } else {
11034           return (String) ref;
11035         }
11036       }
11037       public Builder setName(String value) {
11038         if (value == null) {
11039     throw new NullPointerException();
11040   }
11041   bitField0_ |= 0x00000001;
11042         name_ = value;
11043         onChanged();
11044         return this;
11045       }
11046       public Builder clearName() {
11047         bitField0_ = (bitField0_ & ~0x00000001);
11048         name_ = getDefaultInstance().getName();
11049         onChanged();
11050         return this;
11051       }
11052       void setName(com.google.protobuf.ByteString value) {
11053         bitField0_ |= 0x00000001;
11054         name_ = value;
11055         onChanged();
11056       }
11057
11058       // optional .openxc.DynamicField value = 2;
11059       private com.openxc.BinaryMessages.DynamicField value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
11060       private com.google.protobuf.SingleFieldBuilder<
11061           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder> valueBuilder_;
11062       public boolean hasValue() {
11063         return ((bitField0_ & 0x00000002) == 0x00000002);
11064       }
11065       public com.openxc.BinaryMessages.DynamicField getValue() {
11066         if (valueBuilder_ == null) {
11067           return value_;
11068         } else {
11069           return valueBuilder_.getMessage();
11070         }
11071       }
11072       public Builder setValue(com.openxc.BinaryMessages.DynamicField value) {
11073         if (valueBuilder_ == null) {
11074           if (value == null) {
11075             throw new NullPointerException();
11076           }
11077           value_ = value;
11078           onChanged();
11079         } else {
11080           valueBuilder_.setMessage(value);
11081         }
11082         bitField0_ |= 0x00000002;
11083         return this;
11084       }
11085       public Builder setValue(
11086           com.openxc.BinaryMessages.DynamicField.Builder builderForValue) {
11087         if (valueBuilder_ == null) {
11088           value_ = builderForValue.build();
11089           onChanged();
11090         } else {
11091           valueBuilder_.setMessage(builderForValue.build());
11092         }
11093         bitField0_ |= 0x00000002;
11094         return this;
11095       }
11096       public Builder mergeValue(com.openxc.BinaryMessages.DynamicField value) {
11097         if (valueBuilder_ == null) {
11098           if (((bitField0_ & 0x00000002) == 0x00000002) &&
11099               value_ != com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) {
11100             value_ =
11101               com.openxc.BinaryMessages.DynamicField.newBuilder(value_).mergeFrom(value).buildPartial();
11102           } else {
11103             value_ = value;
11104           }
11105           onChanged();
11106         } else {
11107           valueBuilder_.mergeFrom(value);
11108         }
11109         bitField0_ |= 0x00000002;
11110         return this;
11111       }
11112       public Builder clearValue() {
11113         if (valueBuilder_ == null) {
11114           value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
11115           onChanged();
11116         } else {
11117           valueBuilder_.clear();
11118         }
11119         bitField0_ = (bitField0_ & ~0x00000002);
11120         return this;
11121       }
11122       public com.openxc.BinaryMessages.DynamicField.Builder getValueBuilder() {
11123         bitField0_ |= 0x00000002;
11124         onChanged();
11125         return getValueFieldBuilder().getBuilder();
11126       }
11127       public com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder() {
11128         if (valueBuilder_ != null) {
11129           return valueBuilder_.getMessageOrBuilder();
11130         } else {
11131           return value_;
11132         }
11133       }
11134       private com.google.protobuf.SingleFieldBuilder<
11135           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>
11136           getValueFieldBuilder() {
11137         if (valueBuilder_ == null) {
11138           valueBuilder_ = new com.google.protobuf.SingleFieldBuilder<
11139               com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>(
11140                   value_,
11141                   getParentForChildren(),
11142                   isClean());
11143           value_ = null;
11144         }
11145         return valueBuilder_;
11146       }
11147
11148       // optional .openxc.DynamicField event = 3;
11149       private com.openxc.BinaryMessages.DynamicField event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
11150       private com.google.protobuf.SingleFieldBuilder<
11151           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder> eventBuilder_;
11152       public boolean hasEvent() {
11153         return ((bitField0_ & 0x00000004) == 0x00000004);
11154       }
11155       public com.openxc.BinaryMessages.DynamicField getEvent() {
11156         if (eventBuilder_ == null) {
11157           return event_;
11158         } else {
11159           return eventBuilder_.getMessage();
11160         }
11161       }
11162       public Builder setEvent(com.openxc.BinaryMessages.DynamicField value) {
11163         if (eventBuilder_ == null) {
11164           if (value == null) {
11165             throw new NullPointerException();
11166           }
11167           event_ = value;
11168           onChanged();
11169         } else {
11170           eventBuilder_.setMessage(value);
11171         }
11172         bitField0_ |= 0x00000004;
11173         return this;
11174       }
11175       public Builder setEvent(
11176           com.openxc.BinaryMessages.DynamicField.Builder builderForValue) {
11177         if (eventBuilder_ == null) {
11178           event_ = builderForValue.build();
11179           onChanged();
11180         } else {
11181           eventBuilder_.setMessage(builderForValue.build());
11182         }
11183         bitField0_ |= 0x00000004;
11184         return this;
11185       }
11186       public Builder mergeEvent(com.openxc.BinaryMessages.DynamicField value) {
11187         if (eventBuilder_ == null) {
11188           if (((bitField0_ & 0x00000004) == 0x00000004) &&
11189               event_ != com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) {
11190             event_ =
11191               com.openxc.BinaryMessages.DynamicField.newBuilder(event_).mergeFrom(value).buildPartial();
11192           } else {
11193             event_ = value;
11194           }
11195           onChanged();
11196         } else {
11197           eventBuilder_.mergeFrom(value);
11198         }
11199         bitField0_ |= 0x00000004;
11200         return this;
11201       }
11202       public Builder clearEvent() {
11203         if (eventBuilder_ == null) {
11204           event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
11205           onChanged();
11206         } else {
11207           eventBuilder_.clear();
11208         }
11209         bitField0_ = (bitField0_ & ~0x00000004);
11210         return this;
11211       }
11212       public com.openxc.BinaryMessages.DynamicField.Builder getEventBuilder() {
11213         bitField0_ |= 0x00000004;
11214         onChanged();
11215         return getEventFieldBuilder().getBuilder();
11216       }
11217       public com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder() {
11218         if (eventBuilder_ != null) {
11219           return eventBuilder_.getMessageOrBuilder();
11220         } else {
11221           return event_;
11222         }
11223       }
11224       private com.google.protobuf.SingleFieldBuilder<
11225           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>
11226           getEventFieldBuilder() {
11227         if (eventBuilder_ == null) {
11228           eventBuilder_ = new com.google.protobuf.SingleFieldBuilder<
11229               com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>(
11230                   event_,
11231                   getParentForChildren(),
11232                   isClean());
11233           event_ = null;
11234         }
11235         return eventBuilder_;
11236       }
11237
11238       // @@protoc_insertion_point(builder_scope:openxc.SimpleMessage)
11239     }
11240
11241     static {
11242       defaultInstance = new SimpleMessage(true);
11243       defaultInstance.initFields();
11244     }
11245
11246     // @@protoc_insertion_point(class_scope:openxc.SimpleMessage)
11247   }
11248
11249   private static com.google.protobuf.Descriptors.Descriptor
11250     internal_static_openxc_VehicleMessage_descriptor;
11251   private static
11252     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11253       internal_static_openxc_VehicleMessage_fieldAccessorTable;
11254   private static com.google.protobuf.Descriptors.Descriptor
11255     internal_static_openxc_CanMessage_descriptor;
11256   private static
11257     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11258       internal_static_openxc_CanMessage_fieldAccessorTable;
11259   private static com.google.protobuf.Descriptors.Descriptor
11260     internal_static_openxc_ControlCommand_descriptor;
11261   private static
11262     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11263       internal_static_openxc_ControlCommand_fieldAccessorTable;
11264   private static com.google.protobuf.Descriptors.Descriptor
11265     internal_static_openxc_DiagnosticControlCommand_descriptor;
11266   private static
11267     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11268       internal_static_openxc_DiagnosticControlCommand_fieldAccessorTable;
11269   private static com.google.protobuf.Descriptors.Descriptor
11270     internal_static_openxc_PassthroughModeControlCommand_descriptor;
11271   private static
11272     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11273       internal_static_openxc_PassthroughModeControlCommand_fieldAccessorTable;
11274   private static com.google.protobuf.Descriptors.Descriptor
11275     internal_static_openxc_AcceptanceFilterBypassCommand_descriptor;
11276   private static
11277     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11278       internal_static_openxc_AcceptanceFilterBypassCommand_fieldAccessorTable;
11279   private static com.google.protobuf.Descriptors.Descriptor
11280     internal_static_openxc_PayloadFormatCommand_descriptor;
11281   private static
11282     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11283       internal_static_openxc_PayloadFormatCommand_fieldAccessorTable;
11284   private static com.google.protobuf.Descriptors.Descriptor
11285     internal_static_openxc_PredefinedObd2RequestsCommand_descriptor;
11286   private static
11287     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11288       internal_static_openxc_PredefinedObd2RequestsCommand_fieldAccessorTable;
11289   private static com.google.protobuf.Descriptors.Descriptor
11290     internal_static_openxc_NetworkOperatorSettings_descriptor;
11291   private static
11292     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11293       internal_static_openxc_NetworkOperatorSettings_fieldAccessorTable;
11294   private static com.google.protobuf.Descriptors.Descriptor
11295     internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_descriptor;
11296   private static
11297     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11298       internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_fieldAccessorTable;
11299   private static com.google.protobuf.Descriptors.Descriptor
11300     internal_static_openxc_NetworkDataSettings_descriptor;
11301   private static
11302     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11303       internal_static_openxc_NetworkDataSettings_fieldAccessorTable;
11304   private static com.google.protobuf.Descriptors.Descriptor
11305     internal_static_openxc_ServerConnectSettings_descriptor;
11306   private static
11307     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11308       internal_static_openxc_ServerConnectSettings_fieldAccessorTable;
11309   private static com.google.protobuf.Descriptors.Descriptor
11310     internal_static_openxc_ModemConfigurationCommand_descriptor;
11311   private static
11312     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11313       internal_static_openxc_ModemConfigurationCommand_fieldAccessorTable;
11314   private static com.google.protobuf.Descriptors.Descriptor
11315     internal_static_openxc_CommandResponse_descriptor;
11316   private static
11317     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11318       internal_static_openxc_CommandResponse_fieldAccessorTable;
11319   private static com.google.protobuf.Descriptors.Descriptor
11320     internal_static_openxc_DiagnosticRequest_descriptor;
11321   private static
11322     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11323       internal_static_openxc_DiagnosticRequest_fieldAccessorTable;
11324   private static com.google.protobuf.Descriptors.Descriptor
11325     internal_static_openxc_DiagnosticResponse_descriptor;
11326   private static
11327     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11328       internal_static_openxc_DiagnosticResponse_fieldAccessorTable;
11329   private static com.google.protobuf.Descriptors.Descriptor
11330     internal_static_openxc_DynamicField_descriptor;
11331   private static
11332     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11333       internal_static_openxc_DynamicField_fieldAccessorTable;
11334   private static com.google.protobuf.Descriptors.Descriptor
11335     internal_static_openxc_SimpleMessage_descriptor;
11336   private static
11337     com.google.protobuf.GeneratedMessage.FieldAccessorTable
11338       internal_static_openxc_SimpleMessage_fieldAccessorTable;
11339
11340   public static com.google.protobuf.Descriptors.FileDescriptor
11341       getDescriptor() {
11342     return descriptor;
11343   }
11344   private static com.google.protobuf.Descriptors.FileDescriptor
11345       descriptor;
11346   static {
11347     java.lang.String[] descriptorData = {
11348       "\n\014openxc.proto\022\006openxc\"\230\003\n\016VehicleMessag" +
11349       "e\022)\n\004type\030\001 \001(\0162\033.openxc.VehicleMessage." +
11350       "Type\022\'\n\013can_message\030\002 \001(\0132\022.openxc.CanMe" +
11351       "ssage\022-\n\016simple_message\030\003 \001(\0132\025.openxc.S" +
11352       "impleMessage\0227\n\023diagnostic_response\030\004 \001(" +
11353       "\0132\032.openxc.DiagnosticResponse\022/\n\017control" +
11354       "_command\030\005 \001(\0132\026.openxc.ControlCommand\0221" +
11355       "\n\020command_response\030\006 \001(\0132\027.openxc.Comman" +
11356       "dResponse\022\016\n\006uptime\030\007 \001(\r\"V\n\004Type\022\007\n\003CAN" +
11357       "\020\001\022\n\n\006SIMPLE\020\002\022\016\n\nDIAGNOSTIC\020\003\022\023\n\017CONTRO",
11358       "L_COMMAND\020\004\022\024\n\020COMMAND_RESPONSE\020\005\"\224\001\n\nCa" +
11359       "nMessage\022\013\n\003bus\030\001 \001(\005\022\n\n\002id\030\002 \001(\r\022\014\n\004dat" +
11360       "a\030\003 \001(\014\0224\n\014frame_format\030\004 \001(\0162\036.openxc.C" +
11361       "anMessage.FrameFormat\")\n\013FrameFormat\022\014\n\010" +
11362       "STANDARD\020\001\022\014\n\010EXTENDED\020\002\"\231\005\n\016ControlComm" +
11363       "and\022)\n\004type\030\001 \001(\0162\033.openxc.ControlComman" +
11364       "d.Type\022<\n\022diagnostic_request\030\002 \001(\0132 .ope" +
11365       "nxc.DiagnosticControlCommand\022G\n\030passthro" +
11366       "ugh_mode_request\030\003 \001(\0132%.openxc.Passthro" +
11367       "ughModeControlCommand\022O\n acceptance_filt",
11368       "er_bypass_command\030\004 \001(\0132%.openxc.Accepta" +
11369       "nceFilterBypassCommand\022<\n\026payload_format" +
11370       "_command\030\005 \001(\0132\034.openxc.PayloadFormatCom" +
11371       "mand\022O\n predefined_obd2_requests_command" +
11372       "\030\006 \001(\0132%.openxc.PredefinedObd2RequestsCo" +
11373       "mmand\022F\n\033modem_configuration_command\030\007 \001" +
11374       "(\0132!.openxc.ModemConfigurationCommand\"\254\001" +
11375       "\n\004Type\022\013\n\007VERSION\020\001\022\r\n\tDEVICE_ID\020\002\022\016\n\nDI" +
11376       "AGNOSTIC\020\003\022\017\n\013PASSTHROUGH\020\004\022\034\n\030ACCEPTANC" +
11377       "E_FILTER_BYPASS\020\005\022\022\n\016PAYLOAD_FORMAT\020\006\022\034\n",
11378       "\030PREDEFINED_OBD2_REQUESTS\020\007\022\027\n\023MODEM_CON" +
11379       "FIGURATION\020\010\"\236\001\n\030DiagnosticControlComman" +
11380       "d\022*\n\007request\030\001 \001(\0132\031.openxc.DiagnosticRe" +
11381       "quest\0227\n\006action\030\002 \001(\0162\'.openxc.Diagnosti" +
11382       "cControlCommand.Action\"\035\n\006Action\022\007\n\003ADD\020" +
11383       "\001\022\n\n\006CANCEL\020\002\"=\n\035PassthroughModeControlC" +
11384       "ommand\022\013\n\003bus\030\001 \001(\005\022\017\n\007enabled\030\002 \001(\010\"<\n\035" +
11385       "AcceptanceFilterBypassCommand\022\013\n\003bus\030\001 \001" +
11386       "(\005\022\016\n\006bypass\030\002 \001(\010\"\214\001\n\024PayloadFormatComm" +
11387       "and\022:\n\006format\030\001 \001(\0162*.openxc.PayloadForm",
11388       "atCommand.PayloadFormat\"8\n\rPayloadFormat" +
11389       "\022\010\n\004JSON\020\001\022\014\n\010PROTOBUF\020\002\022\017\n\013MESSAGEPACK\020" +
11390       "\003\"0\n\035PredefinedObd2RequestsCommand\022\017\n\007en" +
11391       "abled\030\001 \001(\010\"\321\003\n\027NetworkOperatorSettings\022" +
11392       "\030\n\020allowDataRoaming\030\001 \001(\010\022N\n\022operatorSel" +
11393       "ectMode\030\002 \001(\01622.openxc.NetworkOperatorSe" +
11394       "ttings.OperatorSelectMode\022L\n\021networkDesc" +
11395       "riptor\030\003 \001(\01321.openxc.NetworkOperatorSet" +
11396       "tings.NetworkDescriptor\032\230\001\n\021NetworkDescr" +
11397       "iptor\022\014\n\004PLMN\030\001 \001(\r\022R\n\013networkType\030\002 \001(\016",
11398       "2=.openxc.NetworkOperatorSettings.Networ" +
11399       "kDescriptor.NetworkType\"!\n\013NetworkType\022\007" +
11400       "\n\003GSM\020\000\022\t\n\005UTRAN\020\002\"c\n\022OperatorSelectMode" +
11401       "\022\r\n\tAUTOMATIC\020\000\022\n\n\006MANUAL\020\001\022\016\n\nDEREGISTE" +
11402       "R\020\002\022\014\n\010SET_ONLY\020\003\022\024\n\020MANUAL_AUTOMATIC\020\004\"" +
11403       "\"\n\023NetworkDataSettings\022\013\n\003APN\030\001 \001(\t\"3\n\025S" +
11404       "erverConnectSettings\022\014\n\004host\030\001 \001(\t\022\014\n\004po" +
11405       "rt\030\002 \001(\r\"\325\001\n\031ModemConfigurationCommand\022@" +
11406       "\n\027networkOperatorSettings\030\001 \001(\0132\037.openxc" +
11407       ".NetworkOperatorSettings\0228\n\023networkDataS",
11408       "ettings\030\002 \001(\0132\033.openxc.NetworkDataSettin" +
11409       "gs\022<\n\025serverConnectSettings\030\003 \001(\0132\035.open" +
11410       "xc.ServerConnectSettings\"]\n\017CommandRespo" +
11411       "nse\022)\n\004type\030\001 \001(\0162\033.openxc.ControlComman" +
11412       "d.Type\022\017\n\007message\030\002 \001(\t\022\016\n\006status\030\003 \001(\010\"" +
11413       "\375\001\n\021DiagnosticRequest\022\013\n\003bus\030\001 \001(\005\022\022\n\nme" +
11414       "ssage_id\030\002 \001(\r\022\014\n\004mode\030\003 \001(\r\022\013\n\003pid\030\004 \001(" +
11415       "\r\022\017\n\007payload\030\005 \001(\014\022\032\n\022multiple_responses" +
11416       "\030\006 \001(\010\022\021\n\tfrequency\030\007 \001(\001\022\014\n\004name\030\010 \001(\t\022" +
11417       ";\n\014decoded_type\030\t \001(\0162%.openxc.Diagnosti",
11418       "cRequest.DecodedType\"!\n\013DecodedType\022\010\n\004N" +
11419       "ONE\020\001\022\010\n\004OBD2\020\002\"\241\001\n\022DiagnosticResponse\022\013" +
11420       "\n\003bus\030\001 \001(\005\022\022\n\nmessage_id\030\002 \001(\r\022\014\n\004mode\030" +
11421       "\003 \001(\r\022\013\n\003pid\030\004 \001(\r\022\017\n\007success\030\005 \001(\010\022\036\n\026n" +
11422       "egative_response_code\030\006 \001(\r\022\017\n\007payload\030\007" +
11423       " \001(\014\022\r\n\005value\030\010 \001(\001\"\242\001\n\014DynamicField\022\'\n\004" +
11424       "type\030\001 \001(\0162\031.openxc.DynamicField.Type\022\024\n" +
11425       "\014string_value\030\002 \001(\t\022\025\n\rnumeric_value\030\003 \001" +
11426       "(\001\022\025\n\rboolean_value\030\004 \001(\010\"%\n\004Type\022\n\n\006STR" +
11427       "ING\020\001\022\007\n\003NUM\020\002\022\010\n\004BOOL\020\003\"g\n\rSimpleMessag",
11428       "e\022\014\n\004name\030\001 \001(\t\022#\n\005value\030\002 \001(\0132\024.openxc." +
11429       "DynamicField\022#\n\005event\030\003 \001(\0132\024.openxc.Dyn" +
11430       "amicFieldB\034\n\ncom.openxcB\016BinaryMessages"
11431     };
11432     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
11433       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
11434         public com.google.protobuf.ExtensionRegistry assignDescriptors(
11435             com.google.protobuf.Descriptors.FileDescriptor root) {
11436           descriptor = root;
11437           internal_static_openxc_VehicleMessage_descriptor =
11438             getDescriptor().getMessageTypes().get(0);
11439           internal_static_openxc_VehicleMessage_fieldAccessorTable = new
11440             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11441               internal_static_openxc_VehicleMessage_descriptor,
11442               new java.lang.String[] { "Type", "CanMessage", "SimpleMessage", "DiagnosticResponse", "ControlCommand", "CommandResponse", "Uptime", },
11443               com.openxc.BinaryMessages.VehicleMessage.class,
11444               com.openxc.BinaryMessages.VehicleMessage.Builder.class);
11445           internal_static_openxc_CanMessage_descriptor =
11446             getDescriptor().getMessageTypes().get(1);
11447           internal_static_openxc_CanMessage_fieldAccessorTable = new
11448             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11449               internal_static_openxc_CanMessage_descriptor,
11450               new java.lang.String[] { "Bus", "Id", "Data", "FrameFormat", },
11451               com.openxc.BinaryMessages.CanMessage.class,
11452               com.openxc.BinaryMessages.CanMessage.Builder.class);
11453           internal_static_openxc_ControlCommand_descriptor =
11454             getDescriptor().getMessageTypes().get(2);
11455           internal_static_openxc_ControlCommand_fieldAccessorTable = new
11456             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11457               internal_static_openxc_ControlCommand_descriptor,
11458               new java.lang.String[] { "Type", "DiagnosticRequest", "PassthroughModeRequest", "AcceptanceFilterBypassCommand", "PayloadFormatCommand", "PredefinedObd2RequestsCommand", "ModemConfigurationCommand", },
11459               com.openxc.BinaryMessages.ControlCommand.class,
11460               com.openxc.BinaryMessages.ControlCommand.Builder.class);
11461           internal_static_openxc_DiagnosticControlCommand_descriptor =
11462             getDescriptor().getMessageTypes().get(3);
11463           internal_static_openxc_DiagnosticControlCommand_fieldAccessorTable = new
11464             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11465               internal_static_openxc_DiagnosticControlCommand_descriptor,
11466               new java.lang.String[] { "Request", "Action", },
11467               com.openxc.BinaryMessages.DiagnosticControlCommand.class,
11468               com.openxc.BinaryMessages.DiagnosticControlCommand.Builder.class);
11469           internal_static_openxc_PassthroughModeControlCommand_descriptor =
11470             getDescriptor().getMessageTypes().get(4);
11471           internal_static_openxc_PassthroughModeControlCommand_fieldAccessorTable = new
11472             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11473               internal_static_openxc_PassthroughModeControlCommand_descriptor,
11474               new java.lang.String[] { "Bus", "Enabled", },
11475               com.openxc.BinaryMessages.PassthroughModeControlCommand.class,
11476               com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder.class);
11477           internal_static_openxc_AcceptanceFilterBypassCommand_descriptor =
11478             getDescriptor().getMessageTypes().get(5);
11479           internal_static_openxc_AcceptanceFilterBypassCommand_fieldAccessorTable = new
11480             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11481               internal_static_openxc_AcceptanceFilterBypassCommand_descriptor,
11482               new java.lang.String[] { "Bus", "Bypass", },
11483               com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.class,
11484               com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.Builder.class);
11485           internal_static_openxc_PayloadFormatCommand_descriptor =
11486             getDescriptor().getMessageTypes().get(6);
11487           internal_static_openxc_PayloadFormatCommand_fieldAccessorTable = new
11488             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11489               internal_static_openxc_PayloadFormatCommand_descriptor,
11490               new java.lang.String[] { "Format", },
11491               com.openxc.BinaryMessages.PayloadFormatCommand.class,
11492               com.openxc.BinaryMessages.PayloadFormatCommand.Builder.class);
11493           internal_static_openxc_PredefinedObd2RequestsCommand_descriptor =
11494             getDescriptor().getMessageTypes().get(7);
11495           internal_static_openxc_PredefinedObd2RequestsCommand_fieldAccessorTable = new
11496             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11497               internal_static_openxc_PredefinedObd2RequestsCommand_descriptor,
11498               new java.lang.String[] { "Enabled", },
11499               com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.class,
11500               com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.Builder.class);
11501           internal_static_openxc_NetworkOperatorSettings_descriptor =
11502             getDescriptor().getMessageTypes().get(8);
11503           internal_static_openxc_NetworkOperatorSettings_fieldAccessorTable = new
11504             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11505               internal_static_openxc_NetworkOperatorSettings_descriptor,
11506               new java.lang.String[] { "AllowDataRoaming", "OperatorSelectMode", "NetworkDescriptor", },
11507               com.openxc.BinaryMessages.NetworkOperatorSettings.class,
11508               com.openxc.BinaryMessages.NetworkOperatorSettings.Builder.class);
11509           internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_descriptor =
11510             internal_static_openxc_NetworkOperatorSettings_descriptor.getNestedTypes().get(0);
11511           internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_fieldAccessorTable = new
11512             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11513               internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_descriptor,
11514               new java.lang.String[] { "PLMN", "NetworkType", },
11515               com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.class,
11516               com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.Builder.class);
11517           internal_static_openxc_NetworkDataSettings_descriptor =
11518             getDescriptor().getMessageTypes().get(9);
11519           internal_static_openxc_NetworkDataSettings_fieldAccessorTable = new
11520             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11521               internal_static_openxc_NetworkDataSettings_descriptor,
11522               new java.lang.String[] { "APN", },
11523               com.openxc.BinaryMessages.NetworkDataSettings.class,
11524               com.openxc.BinaryMessages.NetworkDataSettings.Builder.class);
11525           internal_static_openxc_ServerConnectSettings_descriptor =
11526             getDescriptor().getMessageTypes().get(10);
11527           internal_static_openxc_ServerConnectSettings_fieldAccessorTable = new
11528             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11529               internal_static_openxc_ServerConnectSettings_descriptor,
11530               new java.lang.String[] { "Host", "Port", },
11531               com.openxc.BinaryMessages.ServerConnectSettings.class,
11532               com.openxc.BinaryMessages.ServerConnectSettings.Builder.class);
11533           internal_static_openxc_ModemConfigurationCommand_descriptor =
11534             getDescriptor().getMessageTypes().get(11);
11535           internal_static_openxc_ModemConfigurationCommand_fieldAccessorTable = new
11536             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11537               internal_static_openxc_ModemConfigurationCommand_descriptor,
11538               new java.lang.String[] { "NetworkOperatorSettings", "NetworkDataSettings", "ServerConnectSettings", },
11539               com.openxc.BinaryMessages.ModemConfigurationCommand.class,
11540               com.openxc.BinaryMessages.ModemConfigurationCommand.Builder.class);
11541           internal_static_openxc_CommandResponse_descriptor =
11542             getDescriptor().getMessageTypes().get(12);
11543           internal_static_openxc_CommandResponse_fieldAccessorTable = new
11544             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11545               internal_static_openxc_CommandResponse_descriptor,
11546               new java.lang.String[] { "Type", "Message", "Status", },
11547               com.openxc.BinaryMessages.CommandResponse.class,
11548               com.openxc.BinaryMessages.CommandResponse.Builder.class);
11549           internal_static_openxc_DiagnosticRequest_descriptor =
11550             getDescriptor().getMessageTypes().get(13);
11551           internal_static_openxc_DiagnosticRequest_fieldAccessorTable = new
11552             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11553               internal_static_openxc_DiagnosticRequest_descriptor,
11554               new java.lang.String[] { "Bus", "MessageId", "Mode", "Pid", "Payload", "MultipleResponses", "Frequency", "Name", "DecodedType", },
11555               com.openxc.BinaryMessages.DiagnosticRequest.class,
11556               com.openxc.BinaryMessages.DiagnosticRequest.Builder.class);
11557           internal_static_openxc_DiagnosticResponse_descriptor =
11558             getDescriptor().getMessageTypes().get(14);
11559           internal_static_openxc_DiagnosticResponse_fieldAccessorTable = new
11560             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11561               internal_static_openxc_DiagnosticResponse_descriptor,
11562               new java.lang.String[] { "Bus", "MessageId", "Mode", "Pid", "Success", "NegativeResponseCode", "Payload", "Value", },
11563               com.openxc.BinaryMessages.DiagnosticResponse.class,
11564               com.openxc.BinaryMessages.DiagnosticResponse.Builder.class);
11565           internal_static_openxc_DynamicField_descriptor =
11566             getDescriptor().getMessageTypes().get(15);
11567           internal_static_openxc_DynamicField_fieldAccessorTable = new
11568             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11569               internal_static_openxc_DynamicField_descriptor,
11570               new java.lang.String[] { "Type", "StringValue", "NumericValue", "BooleanValue", },
11571               com.openxc.BinaryMessages.DynamicField.class,
11572               com.openxc.BinaryMessages.DynamicField.Builder.class);
11573           internal_static_openxc_SimpleMessage_descriptor =
11574             getDescriptor().getMessageTypes().get(16);
11575           internal_static_openxc_SimpleMessage_fieldAccessorTable = new
11576             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
11577               internal_static_openxc_SimpleMessage_descriptor,
11578               new java.lang.String[] { "Name", "Value", "Event", },
11579               com.openxc.BinaryMessages.SimpleMessage.class,
11580               com.openxc.BinaryMessages.SimpleMessage.Builder.class);
11581           return null;
11582         }
11583       };
11584     com.google.protobuf.Descriptors.FileDescriptor
11585       .internalBuildGeneratedFileFrom(descriptorData,
11586         new com.google.protobuf.Descriptors.FileDescriptor[] {
11587         }, assigner);
11588   }
11589
11590   // @@protoc_insertion_point(outer_class_scope)
11591 }