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