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