gen/java/com/openxc/BinaryMessages.java

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