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