Remove parse_payload from diagnostic messages, it's not needed.
[apps/low-level-can-service.git] / 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     /**
16      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
17      */
18     boolean hasType();
19     /**
20      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
21      */
22     com.openxc.BinaryMessages.VehicleMessage.Type getType();
23
24     // optional .openxc.RawMessage raw_message = 2;
25     /**
26      * <code>optional .openxc.RawMessage raw_message = 2;</code>
27      */
28     boolean hasRawMessage();
29     /**
30      * <code>optional .openxc.RawMessage raw_message = 2;</code>
31      */
32     com.openxc.BinaryMessages.RawMessage getRawMessage();
33     /**
34      * <code>optional .openxc.RawMessage raw_message = 2;</code>
35      */
36     com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder();
37
38     // optional .openxc.TranslatedMessage translated_message = 3;
39     /**
40      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
41      */
42     boolean hasTranslatedMessage();
43     /**
44      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
45      */
46     com.openxc.BinaryMessages.TranslatedMessage getTranslatedMessage();
47     /**
48      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
49      */
50     com.openxc.BinaryMessages.TranslatedMessageOrBuilder getTranslatedMessageOrBuilder();
51
52     // optional .openxc.DiagnosticResponse diagnostic_response = 4;
53     /**
54      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
55      */
56     boolean hasDiagnosticResponse();
57     /**
58      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
59      */
60     com.openxc.BinaryMessages.DiagnosticResponse getDiagnosticResponse();
61     /**
62      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
63      */
64     com.openxc.BinaryMessages.DiagnosticResponseOrBuilder getDiagnosticResponseOrBuilder();
65
66     // optional .openxc.ControlCommand control_command = 5;
67     /**
68      * <code>optional .openxc.ControlCommand control_command = 5;</code>
69      */
70     boolean hasControlCommand();
71     /**
72      * <code>optional .openxc.ControlCommand control_command = 5;</code>
73      */
74     com.openxc.BinaryMessages.ControlCommand getControlCommand();
75     /**
76      * <code>optional .openxc.ControlCommand control_command = 5;</code>
77      */
78     com.openxc.BinaryMessages.ControlCommandOrBuilder getControlCommandOrBuilder();
79
80     // optional .openxc.CommandResponse command_response = 6;
81     /**
82      * <code>optional .openxc.CommandResponse command_response = 6;</code>
83      */
84     boolean hasCommandResponse();
85     /**
86      * <code>optional .openxc.CommandResponse command_response = 6;</code>
87      */
88     com.openxc.BinaryMessages.CommandResponse getCommandResponse();
89     /**
90      * <code>optional .openxc.CommandResponse command_response = 6;</code>
91      */
92     com.openxc.BinaryMessages.CommandResponseOrBuilder getCommandResponseOrBuilder();
93   }
94   /**
95    * Protobuf type {@code openxc.VehicleMessage}
96    */
97   public static final class VehicleMessage extends
98       com.google.protobuf.GeneratedMessage
99       implements VehicleMessageOrBuilder {
100     // Use VehicleMessage.newBuilder() to construct.
101     private VehicleMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
102       super(builder);
103       this.unknownFields = builder.getUnknownFields();
104     }
105     private VehicleMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
106
107     private static final VehicleMessage defaultInstance;
108     public static VehicleMessage getDefaultInstance() {
109       return defaultInstance;
110     }
111
112     public VehicleMessage getDefaultInstanceForType() {
113       return defaultInstance;
114     }
115
116     private final com.google.protobuf.UnknownFieldSet unknownFields;
117     @java.lang.Override
118     public final com.google.protobuf.UnknownFieldSet
119         getUnknownFields() {
120       return this.unknownFields;
121     }
122     private VehicleMessage(
123         com.google.protobuf.CodedInputStream input,
124         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
125         throws com.google.protobuf.InvalidProtocolBufferException {
126       initFields();
127       int mutable_bitField0_ = 0;
128       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
129           com.google.protobuf.UnknownFieldSet.newBuilder();
130       try {
131         boolean done = false;
132         while (!done) {
133           int tag = input.readTag();
134           switch (tag) {
135             case 0:
136               done = true;
137               break;
138             default: {
139               if (!parseUnknownField(input, unknownFields,
140                                      extensionRegistry, tag)) {
141                 done = true;
142               }
143               break;
144             }
145             case 8: {
146               int rawValue = input.readEnum();
147               com.openxc.BinaryMessages.VehicleMessage.Type value = com.openxc.BinaryMessages.VehicleMessage.Type.valueOf(rawValue);
148               if (value == null) {
149                 unknownFields.mergeVarintField(1, rawValue);
150               } else {
151                 bitField0_ |= 0x00000001;
152                 type_ = value;
153               }
154               break;
155             }
156             case 18: {
157               com.openxc.BinaryMessages.RawMessage.Builder subBuilder = null;
158               if (((bitField0_ & 0x00000002) == 0x00000002)) {
159                 subBuilder = rawMessage_.toBuilder();
160               }
161               rawMessage_ = input.readMessage(com.openxc.BinaryMessages.RawMessage.PARSER, extensionRegistry);
162               if (subBuilder != null) {
163                 subBuilder.mergeFrom(rawMessage_);
164                 rawMessage_ = subBuilder.buildPartial();
165               }
166               bitField0_ |= 0x00000002;
167               break;
168             }
169             case 26: {
170               com.openxc.BinaryMessages.TranslatedMessage.Builder subBuilder = null;
171               if (((bitField0_ & 0x00000004) == 0x00000004)) {
172                 subBuilder = translatedMessage_.toBuilder();
173               }
174               translatedMessage_ = input.readMessage(com.openxc.BinaryMessages.TranslatedMessage.PARSER, extensionRegistry);
175               if (subBuilder != null) {
176                 subBuilder.mergeFrom(translatedMessage_);
177                 translatedMessage_ = subBuilder.buildPartial();
178               }
179               bitField0_ |= 0x00000004;
180               break;
181             }
182             case 34: {
183               com.openxc.BinaryMessages.DiagnosticResponse.Builder subBuilder = null;
184               if (((bitField0_ & 0x00000008) == 0x00000008)) {
185                 subBuilder = diagnosticResponse_.toBuilder();
186               }
187               diagnosticResponse_ = input.readMessage(com.openxc.BinaryMessages.DiagnosticResponse.PARSER, extensionRegistry);
188               if (subBuilder != null) {
189                 subBuilder.mergeFrom(diagnosticResponse_);
190                 diagnosticResponse_ = subBuilder.buildPartial();
191               }
192               bitField0_ |= 0x00000008;
193               break;
194             }
195             case 42: {
196               com.openxc.BinaryMessages.ControlCommand.Builder subBuilder = null;
197               if (((bitField0_ & 0x00000010) == 0x00000010)) {
198                 subBuilder = controlCommand_.toBuilder();
199               }
200               controlCommand_ = input.readMessage(com.openxc.BinaryMessages.ControlCommand.PARSER, extensionRegistry);
201               if (subBuilder != null) {
202                 subBuilder.mergeFrom(controlCommand_);
203                 controlCommand_ = subBuilder.buildPartial();
204               }
205               bitField0_ |= 0x00000010;
206               break;
207             }
208             case 50: {
209               com.openxc.BinaryMessages.CommandResponse.Builder subBuilder = null;
210               if (((bitField0_ & 0x00000020) == 0x00000020)) {
211                 subBuilder = commandResponse_.toBuilder();
212               }
213               commandResponse_ = input.readMessage(com.openxc.BinaryMessages.CommandResponse.PARSER, extensionRegistry);
214               if (subBuilder != null) {
215                 subBuilder.mergeFrom(commandResponse_);
216                 commandResponse_ = subBuilder.buildPartial();
217               }
218               bitField0_ |= 0x00000020;
219               break;
220             }
221           }
222         }
223       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
224         throw e.setUnfinishedMessage(this);
225       } catch (java.io.IOException e) {
226         throw new com.google.protobuf.InvalidProtocolBufferException(
227             e.getMessage()).setUnfinishedMessage(this);
228       } finally {
229         this.unknownFields = unknownFields.build();
230         makeExtensionsImmutable();
231       }
232     }
233     public static final com.google.protobuf.Descriptors.Descriptor
234         getDescriptor() {
235       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
236     }
237
238     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
239         internalGetFieldAccessorTable() {
240       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable
241           .ensureFieldAccessorsInitialized(
242               com.openxc.BinaryMessages.VehicleMessage.class, com.openxc.BinaryMessages.VehicleMessage.Builder.class);
243     }
244
245     public static com.google.protobuf.Parser<VehicleMessage> PARSER =
246         new com.google.protobuf.AbstractParser<VehicleMessage>() {
247       public VehicleMessage parsePartialFrom(
248           com.google.protobuf.CodedInputStream input,
249           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
250           throws com.google.protobuf.InvalidProtocolBufferException {
251         return new VehicleMessage(input, extensionRegistry);
252       }
253     };
254
255     @java.lang.Override
256     public com.google.protobuf.Parser<VehicleMessage> getParserForType() {
257       return PARSER;
258     }
259
260     /**
261      * Protobuf enum {@code openxc.VehicleMessage.Type}
262      */
263     public enum Type
264         implements com.google.protobuf.ProtocolMessageEnum {
265       /**
266        * <code>RAW = 1;</code>
267        */
268       RAW(0, 1),
269       /**
270        * <code>TRANSLATED = 2;</code>
271        */
272       TRANSLATED(1, 2),
273       /**
274        * <code>DIAGNOSTIC = 3;</code>
275        */
276       DIAGNOSTIC(2, 3),
277       /**
278        * <code>CONTROL_COMMAND = 4;</code>
279        */
280       CONTROL_COMMAND(3, 4),
281       /**
282        * <code>COMMAND_RESPONSE = 5;</code>
283        */
284       COMMAND_RESPONSE(4, 5),
285       ;
286
287       /**
288        * <code>RAW = 1;</code>
289        */
290       public static final int RAW_VALUE = 1;
291       /**
292        * <code>TRANSLATED = 2;</code>
293        */
294       public static final int TRANSLATED_VALUE = 2;
295       /**
296        * <code>DIAGNOSTIC = 3;</code>
297        */
298       public static final int DIAGNOSTIC_VALUE = 3;
299       /**
300        * <code>CONTROL_COMMAND = 4;</code>
301        */
302       public static final int CONTROL_COMMAND_VALUE = 4;
303       /**
304        * <code>COMMAND_RESPONSE = 5;</code>
305        */
306       public static final int COMMAND_RESPONSE_VALUE = 5;
307
308
309       public final int getNumber() { return value; }
310
311       public static Type valueOf(int value) {
312         switch (value) {
313           case 1: return RAW;
314           case 2: return TRANSLATED;
315           case 3: return DIAGNOSTIC;
316           case 4: return CONTROL_COMMAND;
317           case 5: return COMMAND_RESPONSE;
318           default: return null;
319         }
320       }
321
322       public static com.google.protobuf.Internal.EnumLiteMap<Type>
323           internalGetValueMap() {
324         return internalValueMap;
325       }
326       private static com.google.protobuf.Internal.EnumLiteMap<Type>
327           internalValueMap =
328             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
329               public Type findValueByNumber(int number) {
330                 return Type.valueOf(number);
331               }
332             };
333
334       public final com.google.protobuf.Descriptors.EnumValueDescriptor
335           getValueDescriptor() {
336         return getDescriptor().getValues().get(index);
337       }
338       public final com.google.protobuf.Descriptors.EnumDescriptor
339           getDescriptorForType() {
340         return getDescriptor();
341       }
342       public static final com.google.protobuf.Descriptors.EnumDescriptor
343           getDescriptor() {
344         return com.openxc.BinaryMessages.VehicleMessage.getDescriptor().getEnumTypes().get(0);
345       }
346
347       private static final Type[] VALUES = values();
348
349       public static Type valueOf(
350           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
351         if (desc.getType() != getDescriptor()) {
352           throw new java.lang.IllegalArgumentException(
353             "EnumValueDescriptor is not for this type.");
354         }
355         return VALUES[desc.getIndex()];
356       }
357
358       private final int index;
359       private final int value;
360
361       private Type(int index, int value) {
362         this.index = index;
363         this.value = value;
364       }
365
366       // @@protoc_insertion_point(enum_scope:openxc.VehicleMessage.Type)
367     }
368
369     private int bitField0_;
370     // optional .openxc.VehicleMessage.Type type = 1;
371     public static final int TYPE_FIELD_NUMBER = 1;
372     private com.openxc.BinaryMessages.VehicleMessage.Type type_;
373     /**
374      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
375      */
376     public boolean hasType() {
377       return ((bitField0_ & 0x00000001) == 0x00000001);
378     }
379     /**
380      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
381      */
382     public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
383       return type_;
384     }
385
386     // optional .openxc.RawMessage raw_message = 2;
387     public static final int RAW_MESSAGE_FIELD_NUMBER = 2;
388     private com.openxc.BinaryMessages.RawMessage rawMessage_;
389     /**
390      * <code>optional .openxc.RawMessage raw_message = 2;</code>
391      */
392     public boolean hasRawMessage() {
393       return ((bitField0_ & 0x00000002) == 0x00000002);
394     }
395     /**
396      * <code>optional .openxc.RawMessage raw_message = 2;</code>
397      */
398     public com.openxc.BinaryMessages.RawMessage getRawMessage() {
399       return rawMessage_;
400     }
401     /**
402      * <code>optional .openxc.RawMessage raw_message = 2;</code>
403      */
404     public com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder() {
405       return rawMessage_;
406     }
407
408     // optional .openxc.TranslatedMessage translated_message = 3;
409     public static final int TRANSLATED_MESSAGE_FIELD_NUMBER = 3;
410     private com.openxc.BinaryMessages.TranslatedMessage translatedMessage_;
411     /**
412      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
413      */
414     public boolean hasTranslatedMessage() {
415       return ((bitField0_ & 0x00000004) == 0x00000004);
416     }
417     /**
418      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
419      */
420     public com.openxc.BinaryMessages.TranslatedMessage getTranslatedMessage() {
421       return translatedMessage_;
422     }
423     /**
424      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
425      */
426     public com.openxc.BinaryMessages.TranslatedMessageOrBuilder getTranslatedMessageOrBuilder() {
427       return translatedMessage_;
428     }
429
430     // optional .openxc.DiagnosticResponse diagnostic_response = 4;
431     public static final int DIAGNOSTIC_RESPONSE_FIELD_NUMBER = 4;
432     private com.openxc.BinaryMessages.DiagnosticResponse diagnosticResponse_;
433     /**
434      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
435      */
436     public boolean hasDiagnosticResponse() {
437       return ((bitField0_ & 0x00000008) == 0x00000008);
438     }
439     /**
440      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
441      */
442     public com.openxc.BinaryMessages.DiagnosticResponse getDiagnosticResponse() {
443       return diagnosticResponse_;
444     }
445     /**
446      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
447      */
448     public com.openxc.BinaryMessages.DiagnosticResponseOrBuilder getDiagnosticResponseOrBuilder() {
449       return diagnosticResponse_;
450     }
451
452     // optional .openxc.ControlCommand control_command = 5;
453     public static final int CONTROL_COMMAND_FIELD_NUMBER = 5;
454     private com.openxc.BinaryMessages.ControlCommand controlCommand_;
455     /**
456      * <code>optional .openxc.ControlCommand control_command = 5;</code>
457      */
458     public boolean hasControlCommand() {
459       return ((bitField0_ & 0x00000010) == 0x00000010);
460     }
461     /**
462      * <code>optional .openxc.ControlCommand control_command = 5;</code>
463      */
464     public com.openxc.BinaryMessages.ControlCommand getControlCommand() {
465       return controlCommand_;
466     }
467     /**
468      * <code>optional .openxc.ControlCommand control_command = 5;</code>
469      */
470     public com.openxc.BinaryMessages.ControlCommandOrBuilder getControlCommandOrBuilder() {
471       return controlCommand_;
472     }
473
474     // optional .openxc.CommandResponse command_response = 6;
475     public static final int COMMAND_RESPONSE_FIELD_NUMBER = 6;
476     private com.openxc.BinaryMessages.CommandResponse commandResponse_;
477     /**
478      * <code>optional .openxc.CommandResponse command_response = 6;</code>
479      */
480     public boolean hasCommandResponse() {
481       return ((bitField0_ & 0x00000020) == 0x00000020);
482     }
483     /**
484      * <code>optional .openxc.CommandResponse command_response = 6;</code>
485      */
486     public com.openxc.BinaryMessages.CommandResponse getCommandResponse() {
487       return commandResponse_;
488     }
489     /**
490      * <code>optional .openxc.CommandResponse command_response = 6;</code>
491      */
492     public com.openxc.BinaryMessages.CommandResponseOrBuilder getCommandResponseOrBuilder() {
493       return commandResponse_;
494     }
495
496     private void initFields() {
497       type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
498       rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
499       translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
500       diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
501       controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
502       commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
503     }
504     private byte memoizedIsInitialized = -1;
505     public final boolean isInitialized() {
506       byte isInitialized = memoizedIsInitialized;
507       if (isInitialized != -1) return isInitialized == 1;
508
509       memoizedIsInitialized = 1;
510       return true;
511     }
512
513     public void writeTo(com.google.protobuf.CodedOutputStream output)
514                         throws java.io.IOException {
515       getSerializedSize();
516       if (((bitField0_ & 0x00000001) == 0x00000001)) {
517         output.writeEnum(1, type_.getNumber());
518       }
519       if (((bitField0_ & 0x00000002) == 0x00000002)) {
520         output.writeMessage(2, rawMessage_);
521       }
522       if (((bitField0_ & 0x00000004) == 0x00000004)) {
523         output.writeMessage(3, translatedMessage_);
524       }
525       if (((bitField0_ & 0x00000008) == 0x00000008)) {
526         output.writeMessage(4, diagnosticResponse_);
527       }
528       if (((bitField0_ & 0x00000010) == 0x00000010)) {
529         output.writeMessage(5, controlCommand_);
530       }
531       if (((bitField0_ & 0x00000020) == 0x00000020)) {
532         output.writeMessage(6, commandResponse_);
533       }
534       getUnknownFields().writeTo(output);
535     }
536
537     private int memoizedSerializedSize = -1;
538     public int getSerializedSize() {
539       int size = memoizedSerializedSize;
540       if (size != -1) return size;
541
542       size = 0;
543       if (((bitField0_ & 0x00000001) == 0x00000001)) {
544         size += com.google.protobuf.CodedOutputStream
545           .computeEnumSize(1, type_.getNumber());
546       }
547       if (((bitField0_ & 0x00000002) == 0x00000002)) {
548         size += com.google.protobuf.CodedOutputStream
549           .computeMessageSize(2, rawMessage_);
550       }
551       if (((bitField0_ & 0x00000004) == 0x00000004)) {
552         size += com.google.protobuf.CodedOutputStream
553           .computeMessageSize(3, translatedMessage_);
554       }
555       if (((bitField0_ & 0x00000008) == 0x00000008)) {
556         size += com.google.protobuf.CodedOutputStream
557           .computeMessageSize(4, diagnosticResponse_);
558       }
559       if (((bitField0_ & 0x00000010) == 0x00000010)) {
560         size += com.google.protobuf.CodedOutputStream
561           .computeMessageSize(5, controlCommand_);
562       }
563       if (((bitField0_ & 0x00000020) == 0x00000020)) {
564         size += com.google.protobuf.CodedOutputStream
565           .computeMessageSize(6, commandResponse_);
566       }
567       size += getUnknownFields().getSerializedSize();
568       memoizedSerializedSize = size;
569       return size;
570     }
571
572     private static final long serialVersionUID = 0L;
573     @java.lang.Override
574     protected java.lang.Object writeReplace()
575         throws java.io.ObjectStreamException {
576       return super.writeReplace();
577     }
578
579     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
580         com.google.protobuf.ByteString data)
581         throws com.google.protobuf.InvalidProtocolBufferException {
582       return PARSER.parseFrom(data);
583     }
584     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
585         com.google.protobuf.ByteString data,
586         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
587         throws com.google.protobuf.InvalidProtocolBufferException {
588       return PARSER.parseFrom(data, extensionRegistry);
589     }
590     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(byte[] data)
591         throws com.google.protobuf.InvalidProtocolBufferException {
592       return PARSER.parseFrom(data);
593     }
594     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
595         byte[] data,
596         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
597         throws com.google.protobuf.InvalidProtocolBufferException {
598       return PARSER.parseFrom(data, extensionRegistry);
599     }
600     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(java.io.InputStream input)
601         throws java.io.IOException {
602       return PARSER.parseFrom(input);
603     }
604     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
605         java.io.InputStream input,
606         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
607         throws java.io.IOException {
608       return PARSER.parseFrom(input, extensionRegistry);
609     }
610     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(java.io.InputStream input)
611         throws java.io.IOException {
612       return PARSER.parseDelimitedFrom(input);
613     }
614     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(
615         java.io.InputStream input,
616         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
617         throws java.io.IOException {
618       return PARSER.parseDelimitedFrom(input, extensionRegistry);
619     }
620     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
621         com.google.protobuf.CodedInputStream input)
622         throws java.io.IOException {
623       return PARSER.parseFrom(input);
624     }
625     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
626         com.google.protobuf.CodedInputStream input,
627         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
628         throws java.io.IOException {
629       return PARSER.parseFrom(input, extensionRegistry);
630     }
631
632     public static Builder newBuilder() { return Builder.create(); }
633     public Builder newBuilderForType() { return newBuilder(); }
634     public static Builder newBuilder(com.openxc.BinaryMessages.VehicleMessage prototype) {
635       return newBuilder().mergeFrom(prototype);
636     }
637     public Builder toBuilder() { return newBuilder(this); }
638
639     @java.lang.Override
640     protected Builder newBuilderForType(
641         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
642       Builder builder = new Builder(parent);
643       return builder;
644     }
645     /**
646      * Protobuf type {@code openxc.VehicleMessage}
647      */
648     public static final class Builder extends
649         com.google.protobuf.GeneratedMessage.Builder<Builder>
650        implements com.openxc.BinaryMessages.VehicleMessageOrBuilder {
651       public static final com.google.protobuf.Descriptors.Descriptor
652           getDescriptor() {
653         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
654       }
655
656       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
657           internalGetFieldAccessorTable() {
658         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable
659             .ensureFieldAccessorsInitialized(
660                 com.openxc.BinaryMessages.VehicleMessage.class, com.openxc.BinaryMessages.VehicleMessage.Builder.class);
661       }
662
663       // Construct using com.openxc.BinaryMessages.VehicleMessage.newBuilder()
664       private Builder() {
665         maybeForceBuilderInitialization();
666       }
667
668       private Builder(
669           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
670         super(parent);
671         maybeForceBuilderInitialization();
672       }
673       private void maybeForceBuilderInitialization() {
674         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
675           getRawMessageFieldBuilder();
676           getTranslatedMessageFieldBuilder();
677           getDiagnosticResponseFieldBuilder();
678           getControlCommandFieldBuilder();
679           getCommandResponseFieldBuilder();
680         }
681       }
682       private static Builder create() {
683         return new Builder();
684       }
685
686       public Builder clear() {
687         super.clear();
688         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
689         bitField0_ = (bitField0_ & ~0x00000001);
690         if (rawMessageBuilder_ == null) {
691           rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
692         } else {
693           rawMessageBuilder_.clear();
694         }
695         bitField0_ = (bitField0_ & ~0x00000002);
696         if (translatedMessageBuilder_ == null) {
697           translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
698         } else {
699           translatedMessageBuilder_.clear();
700         }
701         bitField0_ = (bitField0_ & ~0x00000004);
702         if (diagnosticResponseBuilder_ == null) {
703           diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
704         } else {
705           diagnosticResponseBuilder_.clear();
706         }
707         bitField0_ = (bitField0_ & ~0x00000008);
708         if (controlCommandBuilder_ == null) {
709           controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
710         } else {
711           controlCommandBuilder_.clear();
712         }
713         bitField0_ = (bitField0_ & ~0x00000010);
714         if (commandResponseBuilder_ == null) {
715           commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
716         } else {
717           commandResponseBuilder_.clear();
718         }
719         bitField0_ = (bitField0_ & ~0x00000020);
720         return this;
721       }
722
723       public Builder clone() {
724         return create().mergeFrom(buildPartial());
725       }
726
727       public com.google.protobuf.Descriptors.Descriptor
728           getDescriptorForType() {
729         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
730       }
731
732       public com.openxc.BinaryMessages.VehicleMessage getDefaultInstanceForType() {
733         return com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance();
734       }
735
736       public com.openxc.BinaryMessages.VehicleMessage build() {
737         com.openxc.BinaryMessages.VehicleMessage result = buildPartial();
738         if (!result.isInitialized()) {
739           throw newUninitializedMessageException(result);
740         }
741         return result;
742       }
743
744       public com.openxc.BinaryMessages.VehicleMessage buildPartial() {
745         com.openxc.BinaryMessages.VehicleMessage result = new com.openxc.BinaryMessages.VehicleMessage(this);
746         int from_bitField0_ = bitField0_;
747         int to_bitField0_ = 0;
748         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
749           to_bitField0_ |= 0x00000001;
750         }
751         result.type_ = type_;
752         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
753           to_bitField0_ |= 0x00000002;
754         }
755         if (rawMessageBuilder_ == null) {
756           result.rawMessage_ = rawMessage_;
757         } else {
758           result.rawMessage_ = rawMessageBuilder_.build();
759         }
760         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
761           to_bitField0_ |= 0x00000004;
762         }
763         if (translatedMessageBuilder_ == null) {
764           result.translatedMessage_ = translatedMessage_;
765         } else {
766           result.translatedMessage_ = translatedMessageBuilder_.build();
767         }
768         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
769           to_bitField0_ |= 0x00000008;
770         }
771         if (diagnosticResponseBuilder_ == null) {
772           result.diagnosticResponse_ = diagnosticResponse_;
773         } else {
774           result.diagnosticResponse_ = diagnosticResponseBuilder_.build();
775         }
776         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
777           to_bitField0_ |= 0x00000010;
778         }
779         if (controlCommandBuilder_ == null) {
780           result.controlCommand_ = controlCommand_;
781         } else {
782           result.controlCommand_ = controlCommandBuilder_.build();
783         }
784         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
785           to_bitField0_ |= 0x00000020;
786         }
787         if (commandResponseBuilder_ == null) {
788           result.commandResponse_ = commandResponse_;
789         } else {
790           result.commandResponse_ = commandResponseBuilder_.build();
791         }
792         result.bitField0_ = to_bitField0_;
793         onBuilt();
794         return result;
795       }
796
797       public Builder mergeFrom(com.google.protobuf.Message other) {
798         if (other instanceof com.openxc.BinaryMessages.VehicleMessage) {
799           return mergeFrom((com.openxc.BinaryMessages.VehicleMessage)other);
800         } else {
801           super.mergeFrom(other);
802           return this;
803         }
804       }
805
806       public Builder mergeFrom(com.openxc.BinaryMessages.VehicleMessage other) {
807         if (other == com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance()) return this;
808         if (other.hasType()) {
809           setType(other.getType());
810         }
811         if (other.hasRawMessage()) {
812           mergeRawMessage(other.getRawMessage());
813         }
814         if (other.hasTranslatedMessage()) {
815           mergeTranslatedMessage(other.getTranslatedMessage());
816         }
817         if (other.hasDiagnosticResponse()) {
818           mergeDiagnosticResponse(other.getDiagnosticResponse());
819         }
820         if (other.hasControlCommand()) {
821           mergeControlCommand(other.getControlCommand());
822         }
823         if (other.hasCommandResponse()) {
824           mergeCommandResponse(other.getCommandResponse());
825         }
826         this.mergeUnknownFields(other.getUnknownFields());
827         return this;
828       }
829
830       public final boolean isInitialized() {
831         return true;
832       }
833
834       public Builder mergeFrom(
835           com.google.protobuf.CodedInputStream input,
836           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
837           throws java.io.IOException {
838         com.openxc.BinaryMessages.VehicleMessage parsedMessage = null;
839         try {
840           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
841         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
842           parsedMessage = (com.openxc.BinaryMessages.VehicleMessage) e.getUnfinishedMessage();
843           throw e;
844         } finally {
845           if (parsedMessage != null) {
846             mergeFrom(parsedMessage);
847           }
848         }
849         return this;
850       }
851       private int bitField0_;
852
853       // optional .openxc.VehicleMessage.Type type = 1;
854       private com.openxc.BinaryMessages.VehicleMessage.Type type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
855       /**
856        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
857        */
858       public boolean hasType() {
859         return ((bitField0_ & 0x00000001) == 0x00000001);
860       }
861       /**
862        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
863        */
864       public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
865         return type_;
866       }
867       /**
868        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
869        */
870       public Builder setType(com.openxc.BinaryMessages.VehicleMessage.Type value) {
871         if (value == null) {
872           throw new NullPointerException();
873         }
874         bitField0_ |= 0x00000001;
875         type_ = value;
876         onChanged();
877         return this;
878       }
879       /**
880        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
881        */
882       public Builder clearType() {
883         bitField0_ = (bitField0_ & ~0x00000001);
884         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
885         onChanged();
886         return this;
887       }
888
889       // optional .openxc.RawMessage raw_message = 2;
890       private com.openxc.BinaryMessages.RawMessage rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
891       private com.google.protobuf.SingleFieldBuilder<
892           com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder> rawMessageBuilder_;
893       /**
894        * <code>optional .openxc.RawMessage raw_message = 2;</code>
895        */
896       public boolean hasRawMessage() {
897         return ((bitField0_ & 0x00000002) == 0x00000002);
898       }
899       /**
900        * <code>optional .openxc.RawMessage raw_message = 2;</code>
901        */
902       public com.openxc.BinaryMessages.RawMessage getRawMessage() {
903         if (rawMessageBuilder_ == null) {
904           return rawMessage_;
905         } else {
906           return rawMessageBuilder_.getMessage();
907         }
908       }
909       /**
910        * <code>optional .openxc.RawMessage raw_message = 2;</code>
911        */
912       public Builder setRawMessage(com.openxc.BinaryMessages.RawMessage value) {
913         if (rawMessageBuilder_ == null) {
914           if (value == null) {
915             throw new NullPointerException();
916           }
917           rawMessage_ = value;
918           onChanged();
919         } else {
920           rawMessageBuilder_.setMessage(value);
921         }
922         bitField0_ |= 0x00000002;
923         return this;
924       }
925       /**
926        * <code>optional .openxc.RawMessage raw_message = 2;</code>
927        */
928       public Builder setRawMessage(
929           com.openxc.BinaryMessages.RawMessage.Builder builderForValue) {
930         if (rawMessageBuilder_ == null) {
931           rawMessage_ = builderForValue.build();
932           onChanged();
933         } else {
934           rawMessageBuilder_.setMessage(builderForValue.build());
935         }
936         bitField0_ |= 0x00000002;
937         return this;
938       }
939       /**
940        * <code>optional .openxc.RawMessage raw_message = 2;</code>
941        */
942       public Builder mergeRawMessage(com.openxc.BinaryMessages.RawMessage value) {
943         if (rawMessageBuilder_ == null) {
944           if (((bitField0_ & 0x00000002) == 0x00000002) &&
945               rawMessage_ != com.openxc.BinaryMessages.RawMessage.getDefaultInstance()) {
946             rawMessage_ =
947               com.openxc.BinaryMessages.RawMessage.newBuilder(rawMessage_).mergeFrom(value).buildPartial();
948           } else {
949             rawMessage_ = value;
950           }
951           onChanged();
952         } else {
953           rawMessageBuilder_.mergeFrom(value);
954         }
955         bitField0_ |= 0x00000002;
956         return this;
957       }
958       /**
959        * <code>optional .openxc.RawMessage raw_message = 2;</code>
960        */
961       public Builder clearRawMessage() {
962         if (rawMessageBuilder_ == null) {
963           rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
964           onChanged();
965         } else {
966           rawMessageBuilder_.clear();
967         }
968         bitField0_ = (bitField0_ & ~0x00000002);
969         return this;
970       }
971       /**
972        * <code>optional .openxc.RawMessage raw_message = 2;</code>
973        */
974       public com.openxc.BinaryMessages.RawMessage.Builder getRawMessageBuilder() {
975         bitField0_ |= 0x00000002;
976         onChanged();
977         return getRawMessageFieldBuilder().getBuilder();
978       }
979       /**
980        * <code>optional .openxc.RawMessage raw_message = 2;</code>
981        */
982       public com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder() {
983         if (rawMessageBuilder_ != null) {
984           return rawMessageBuilder_.getMessageOrBuilder();
985         } else {
986           return rawMessage_;
987         }
988       }
989       /**
990        * <code>optional .openxc.RawMessage raw_message = 2;</code>
991        */
992       private com.google.protobuf.SingleFieldBuilder<
993           com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder> 
994           getRawMessageFieldBuilder() {
995         if (rawMessageBuilder_ == null) {
996           rawMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
997               com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder>(
998                   rawMessage_,
999                   getParentForChildren(),
1000                   isClean());
1001           rawMessage_ = null;
1002         }
1003         return rawMessageBuilder_;
1004       }
1005
1006       // optional .openxc.TranslatedMessage translated_message = 3;
1007       private com.openxc.BinaryMessages.TranslatedMessage translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
1008       private com.google.protobuf.SingleFieldBuilder<
1009           com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder> translatedMessageBuilder_;
1010       /**
1011        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1012        */
1013       public boolean hasTranslatedMessage() {
1014         return ((bitField0_ & 0x00000004) == 0x00000004);
1015       }
1016       /**
1017        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1018        */
1019       public com.openxc.BinaryMessages.TranslatedMessage getTranslatedMessage() {
1020         if (translatedMessageBuilder_ == null) {
1021           return translatedMessage_;
1022         } else {
1023           return translatedMessageBuilder_.getMessage();
1024         }
1025       }
1026       /**
1027        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1028        */
1029       public Builder setTranslatedMessage(com.openxc.BinaryMessages.TranslatedMessage value) {
1030         if (translatedMessageBuilder_ == null) {
1031           if (value == null) {
1032             throw new NullPointerException();
1033           }
1034           translatedMessage_ = value;
1035           onChanged();
1036         } else {
1037           translatedMessageBuilder_.setMessage(value);
1038         }
1039         bitField0_ |= 0x00000004;
1040         return this;
1041       }
1042       /**
1043        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1044        */
1045       public Builder setTranslatedMessage(
1046           com.openxc.BinaryMessages.TranslatedMessage.Builder builderForValue) {
1047         if (translatedMessageBuilder_ == null) {
1048           translatedMessage_ = builderForValue.build();
1049           onChanged();
1050         } else {
1051           translatedMessageBuilder_.setMessage(builderForValue.build());
1052         }
1053         bitField0_ |= 0x00000004;
1054         return this;
1055       }
1056       /**
1057        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1058        */
1059       public Builder mergeTranslatedMessage(com.openxc.BinaryMessages.TranslatedMessage value) {
1060         if (translatedMessageBuilder_ == null) {
1061           if (((bitField0_ & 0x00000004) == 0x00000004) &&
1062               translatedMessage_ != com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance()) {
1063             translatedMessage_ =
1064               com.openxc.BinaryMessages.TranslatedMessage.newBuilder(translatedMessage_).mergeFrom(value).buildPartial();
1065           } else {
1066             translatedMessage_ = value;
1067           }
1068           onChanged();
1069         } else {
1070           translatedMessageBuilder_.mergeFrom(value);
1071         }
1072         bitField0_ |= 0x00000004;
1073         return this;
1074       }
1075       /**
1076        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1077        */
1078       public Builder clearTranslatedMessage() {
1079         if (translatedMessageBuilder_ == null) {
1080           translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
1081           onChanged();
1082         } else {
1083           translatedMessageBuilder_.clear();
1084         }
1085         bitField0_ = (bitField0_ & ~0x00000004);
1086         return this;
1087       }
1088       /**
1089        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1090        */
1091       public com.openxc.BinaryMessages.TranslatedMessage.Builder getTranslatedMessageBuilder() {
1092         bitField0_ |= 0x00000004;
1093         onChanged();
1094         return getTranslatedMessageFieldBuilder().getBuilder();
1095       }
1096       /**
1097        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1098        */
1099       public com.openxc.BinaryMessages.TranslatedMessageOrBuilder getTranslatedMessageOrBuilder() {
1100         if (translatedMessageBuilder_ != null) {
1101           return translatedMessageBuilder_.getMessageOrBuilder();
1102         } else {
1103           return translatedMessage_;
1104         }
1105       }
1106       /**
1107        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1108        */
1109       private com.google.protobuf.SingleFieldBuilder<
1110           com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder> 
1111           getTranslatedMessageFieldBuilder() {
1112         if (translatedMessageBuilder_ == null) {
1113           translatedMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1114               com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder>(
1115                   translatedMessage_,
1116                   getParentForChildren(),
1117                   isClean());
1118           translatedMessage_ = null;
1119         }
1120         return translatedMessageBuilder_;
1121       }
1122
1123       // optional .openxc.DiagnosticResponse diagnostic_response = 4;
1124       private com.openxc.BinaryMessages.DiagnosticResponse diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
1125       private com.google.protobuf.SingleFieldBuilder<
1126           com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder> diagnosticResponseBuilder_;
1127       /**
1128        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1129        */
1130       public boolean hasDiagnosticResponse() {
1131         return ((bitField0_ & 0x00000008) == 0x00000008);
1132       }
1133       /**
1134        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1135        */
1136       public com.openxc.BinaryMessages.DiagnosticResponse getDiagnosticResponse() {
1137         if (diagnosticResponseBuilder_ == null) {
1138           return diagnosticResponse_;
1139         } else {
1140           return diagnosticResponseBuilder_.getMessage();
1141         }
1142       }
1143       /**
1144        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1145        */
1146       public Builder setDiagnosticResponse(com.openxc.BinaryMessages.DiagnosticResponse value) {
1147         if (diagnosticResponseBuilder_ == null) {
1148           if (value == null) {
1149             throw new NullPointerException();
1150           }
1151           diagnosticResponse_ = value;
1152           onChanged();
1153         } else {
1154           diagnosticResponseBuilder_.setMessage(value);
1155         }
1156         bitField0_ |= 0x00000008;
1157         return this;
1158       }
1159       /**
1160        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1161        */
1162       public Builder setDiagnosticResponse(
1163           com.openxc.BinaryMessages.DiagnosticResponse.Builder builderForValue) {
1164         if (diagnosticResponseBuilder_ == null) {
1165           diagnosticResponse_ = builderForValue.build();
1166           onChanged();
1167         } else {
1168           diagnosticResponseBuilder_.setMessage(builderForValue.build());
1169         }
1170         bitField0_ |= 0x00000008;
1171         return this;
1172       }
1173       /**
1174        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1175        */
1176       public Builder mergeDiagnosticResponse(com.openxc.BinaryMessages.DiagnosticResponse value) {
1177         if (diagnosticResponseBuilder_ == null) {
1178           if (((bitField0_ & 0x00000008) == 0x00000008) &&
1179               diagnosticResponse_ != com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance()) {
1180             diagnosticResponse_ =
1181               com.openxc.BinaryMessages.DiagnosticResponse.newBuilder(diagnosticResponse_).mergeFrom(value).buildPartial();
1182           } else {
1183             diagnosticResponse_ = value;
1184           }
1185           onChanged();
1186         } else {
1187           diagnosticResponseBuilder_.mergeFrom(value);
1188         }
1189         bitField0_ |= 0x00000008;
1190         return this;
1191       }
1192       /**
1193        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1194        */
1195       public Builder clearDiagnosticResponse() {
1196         if (diagnosticResponseBuilder_ == null) {
1197           diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
1198           onChanged();
1199         } else {
1200           diagnosticResponseBuilder_.clear();
1201         }
1202         bitField0_ = (bitField0_ & ~0x00000008);
1203         return this;
1204       }
1205       /**
1206        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1207        */
1208       public com.openxc.BinaryMessages.DiagnosticResponse.Builder getDiagnosticResponseBuilder() {
1209         bitField0_ |= 0x00000008;
1210         onChanged();
1211         return getDiagnosticResponseFieldBuilder().getBuilder();
1212       }
1213       /**
1214        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1215        */
1216       public com.openxc.BinaryMessages.DiagnosticResponseOrBuilder getDiagnosticResponseOrBuilder() {
1217         if (diagnosticResponseBuilder_ != null) {
1218           return diagnosticResponseBuilder_.getMessageOrBuilder();
1219         } else {
1220           return diagnosticResponse_;
1221         }
1222       }
1223       /**
1224        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1225        */
1226       private com.google.protobuf.SingleFieldBuilder<
1227           com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder> 
1228           getDiagnosticResponseFieldBuilder() {
1229         if (diagnosticResponseBuilder_ == null) {
1230           diagnosticResponseBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1231               com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder>(
1232                   diagnosticResponse_,
1233                   getParentForChildren(),
1234                   isClean());
1235           diagnosticResponse_ = null;
1236         }
1237         return diagnosticResponseBuilder_;
1238       }
1239
1240       // optional .openxc.ControlCommand control_command = 5;
1241       private com.openxc.BinaryMessages.ControlCommand controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
1242       private com.google.protobuf.SingleFieldBuilder<
1243           com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder> controlCommandBuilder_;
1244       /**
1245        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1246        */
1247       public boolean hasControlCommand() {
1248         return ((bitField0_ & 0x00000010) == 0x00000010);
1249       }
1250       /**
1251        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1252        */
1253       public com.openxc.BinaryMessages.ControlCommand getControlCommand() {
1254         if (controlCommandBuilder_ == null) {
1255           return controlCommand_;
1256         } else {
1257           return controlCommandBuilder_.getMessage();
1258         }
1259       }
1260       /**
1261        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1262        */
1263       public Builder setControlCommand(com.openxc.BinaryMessages.ControlCommand value) {
1264         if (controlCommandBuilder_ == null) {
1265           if (value == null) {
1266             throw new NullPointerException();
1267           }
1268           controlCommand_ = value;
1269           onChanged();
1270         } else {
1271           controlCommandBuilder_.setMessage(value);
1272         }
1273         bitField0_ |= 0x00000010;
1274         return this;
1275       }
1276       /**
1277        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1278        */
1279       public Builder setControlCommand(
1280           com.openxc.BinaryMessages.ControlCommand.Builder builderForValue) {
1281         if (controlCommandBuilder_ == null) {
1282           controlCommand_ = builderForValue.build();
1283           onChanged();
1284         } else {
1285           controlCommandBuilder_.setMessage(builderForValue.build());
1286         }
1287         bitField0_ |= 0x00000010;
1288         return this;
1289       }
1290       /**
1291        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1292        */
1293       public Builder mergeControlCommand(com.openxc.BinaryMessages.ControlCommand value) {
1294         if (controlCommandBuilder_ == null) {
1295           if (((bitField0_ & 0x00000010) == 0x00000010) &&
1296               controlCommand_ != com.openxc.BinaryMessages.ControlCommand.getDefaultInstance()) {
1297             controlCommand_ =
1298               com.openxc.BinaryMessages.ControlCommand.newBuilder(controlCommand_).mergeFrom(value).buildPartial();
1299           } else {
1300             controlCommand_ = value;
1301           }
1302           onChanged();
1303         } else {
1304           controlCommandBuilder_.mergeFrom(value);
1305         }
1306         bitField0_ |= 0x00000010;
1307         return this;
1308       }
1309       /**
1310        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1311        */
1312       public Builder clearControlCommand() {
1313         if (controlCommandBuilder_ == null) {
1314           controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
1315           onChanged();
1316         } else {
1317           controlCommandBuilder_.clear();
1318         }
1319         bitField0_ = (bitField0_ & ~0x00000010);
1320         return this;
1321       }
1322       /**
1323        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1324        */
1325       public com.openxc.BinaryMessages.ControlCommand.Builder getControlCommandBuilder() {
1326         bitField0_ |= 0x00000010;
1327         onChanged();
1328         return getControlCommandFieldBuilder().getBuilder();
1329       }
1330       /**
1331        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1332        */
1333       public com.openxc.BinaryMessages.ControlCommandOrBuilder getControlCommandOrBuilder() {
1334         if (controlCommandBuilder_ != null) {
1335           return controlCommandBuilder_.getMessageOrBuilder();
1336         } else {
1337           return controlCommand_;
1338         }
1339       }
1340       /**
1341        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1342        */
1343       private com.google.protobuf.SingleFieldBuilder<
1344           com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder> 
1345           getControlCommandFieldBuilder() {
1346         if (controlCommandBuilder_ == null) {
1347           controlCommandBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1348               com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder>(
1349                   controlCommand_,
1350                   getParentForChildren(),
1351                   isClean());
1352           controlCommand_ = null;
1353         }
1354         return controlCommandBuilder_;
1355       }
1356
1357       // optional .openxc.CommandResponse command_response = 6;
1358       private com.openxc.BinaryMessages.CommandResponse commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
1359       private com.google.protobuf.SingleFieldBuilder<
1360           com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder> commandResponseBuilder_;
1361       /**
1362        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1363        */
1364       public boolean hasCommandResponse() {
1365         return ((bitField0_ & 0x00000020) == 0x00000020);
1366       }
1367       /**
1368        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1369        */
1370       public com.openxc.BinaryMessages.CommandResponse getCommandResponse() {
1371         if (commandResponseBuilder_ == null) {
1372           return commandResponse_;
1373         } else {
1374           return commandResponseBuilder_.getMessage();
1375         }
1376       }
1377       /**
1378        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1379        */
1380       public Builder setCommandResponse(com.openxc.BinaryMessages.CommandResponse value) {
1381         if (commandResponseBuilder_ == null) {
1382           if (value == null) {
1383             throw new NullPointerException();
1384           }
1385           commandResponse_ = value;
1386           onChanged();
1387         } else {
1388           commandResponseBuilder_.setMessage(value);
1389         }
1390         bitField0_ |= 0x00000020;
1391         return this;
1392       }
1393       /**
1394        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1395        */
1396       public Builder setCommandResponse(
1397           com.openxc.BinaryMessages.CommandResponse.Builder builderForValue) {
1398         if (commandResponseBuilder_ == null) {
1399           commandResponse_ = builderForValue.build();
1400           onChanged();
1401         } else {
1402           commandResponseBuilder_.setMessage(builderForValue.build());
1403         }
1404         bitField0_ |= 0x00000020;
1405         return this;
1406       }
1407       /**
1408        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1409        */
1410       public Builder mergeCommandResponse(com.openxc.BinaryMessages.CommandResponse value) {
1411         if (commandResponseBuilder_ == null) {
1412           if (((bitField0_ & 0x00000020) == 0x00000020) &&
1413               commandResponse_ != com.openxc.BinaryMessages.CommandResponse.getDefaultInstance()) {
1414             commandResponse_ =
1415               com.openxc.BinaryMessages.CommandResponse.newBuilder(commandResponse_).mergeFrom(value).buildPartial();
1416           } else {
1417             commandResponse_ = value;
1418           }
1419           onChanged();
1420         } else {
1421           commandResponseBuilder_.mergeFrom(value);
1422         }
1423         bitField0_ |= 0x00000020;
1424         return this;
1425       }
1426       /**
1427        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1428        */
1429       public Builder clearCommandResponse() {
1430         if (commandResponseBuilder_ == null) {
1431           commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
1432           onChanged();
1433         } else {
1434           commandResponseBuilder_.clear();
1435         }
1436         bitField0_ = (bitField0_ & ~0x00000020);
1437         return this;
1438       }
1439       /**
1440        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1441        */
1442       public com.openxc.BinaryMessages.CommandResponse.Builder getCommandResponseBuilder() {
1443         bitField0_ |= 0x00000020;
1444         onChanged();
1445         return getCommandResponseFieldBuilder().getBuilder();
1446       }
1447       /**
1448        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1449        */
1450       public com.openxc.BinaryMessages.CommandResponseOrBuilder getCommandResponseOrBuilder() {
1451         if (commandResponseBuilder_ != null) {
1452           return commandResponseBuilder_.getMessageOrBuilder();
1453         } else {
1454           return commandResponse_;
1455         }
1456       }
1457       /**
1458        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1459        */
1460       private com.google.protobuf.SingleFieldBuilder<
1461           com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder> 
1462           getCommandResponseFieldBuilder() {
1463         if (commandResponseBuilder_ == null) {
1464           commandResponseBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1465               com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder>(
1466                   commandResponse_,
1467                   getParentForChildren(),
1468                   isClean());
1469           commandResponse_ = null;
1470         }
1471         return commandResponseBuilder_;
1472       }
1473
1474       // @@protoc_insertion_point(builder_scope:openxc.VehicleMessage)
1475     }
1476
1477     static {
1478       defaultInstance = new VehicleMessage(true);
1479       defaultInstance.initFields();
1480     }
1481
1482     // @@protoc_insertion_point(class_scope:openxc.VehicleMessage)
1483   }
1484
1485   public interface RawMessageOrBuilder
1486       extends com.google.protobuf.MessageOrBuilder {
1487
1488     // optional int32 bus = 1;
1489     /**
1490      * <code>optional int32 bus = 1;</code>
1491      */
1492     boolean hasBus();
1493     /**
1494      * <code>optional int32 bus = 1;</code>
1495      */
1496     int getBus();
1497
1498     // optional uint32 message_id = 2;
1499     /**
1500      * <code>optional uint32 message_id = 2;</code>
1501      */
1502     boolean hasMessageId();
1503     /**
1504      * <code>optional uint32 message_id = 2;</code>
1505      */
1506     int getMessageId();
1507
1508     // optional bytes data = 3;
1509     /**
1510      * <code>optional bytes data = 3;</code>
1511      */
1512     boolean hasData();
1513     /**
1514      * <code>optional bytes data = 3;</code>
1515      */
1516     com.google.protobuf.ByteString getData();
1517   }
1518   /**
1519    * Protobuf type {@code openxc.RawMessage}
1520    */
1521   public static final class RawMessage extends
1522       com.google.protobuf.GeneratedMessage
1523       implements RawMessageOrBuilder {
1524     // Use RawMessage.newBuilder() to construct.
1525     private RawMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
1526       super(builder);
1527       this.unknownFields = builder.getUnknownFields();
1528     }
1529     private RawMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
1530
1531     private static final RawMessage defaultInstance;
1532     public static RawMessage getDefaultInstance() {
1533       return defaultInstance;
1534     }
1535
1536     public RawMessage getDefaultInstanceForType() {
1537       return defaultInstance;
1538     }
1539
1540     private final com.google.protobuf.UnknownFieldSet unknownFields;
1541     @java.lang.Override
1542     public final com.google.protobuf.UnknownFieldSet
1543         getUnknownFields() {
1544       return this.unknownFields;
1545     }
1546     private RawMessage(
1547         com.google.protobuf.CodedInputStream input,
1548         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1549         throws com.google.protobuf.InvalidProtocolBufferException {
1550       initFields();
1551       int mutable_bitField0_ = 0;
1552       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
1553           com.google.protobuf.UnknownFieldSet.newBuilder();
1554       try {
1555         boolean done = false;
1556         while (!done) {
1557           int tag = input.readTag();
1558           switch (tag) {
1559             case 0:
1560               done = true;
1561               break;
1562             default: {
1563               if (!parseUnknownField(input, unknownFields,
1564                                      extensionRegistry, tag)) {
1565                 done = true;
1566               }
1567               break;
1568             }
1569             case 8: {
1570               bitField0_ |= 0x00000001;
1571               bus_ = input.readInt32();
1572               break;
1573             }
1574             case 16: {
1575               bitField0_ |= 0x00000002;
1576               messageId_ = input.readUInt32();
1577               break;
1578             }
1579             case 26: {
1580               bitField0_ |= 0x00000004;
1581               data_ = input.readBytes();
1582               break;
1583             }
1584           }
1585         }
1586       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1587         throw e.setUnfinishedMessage(this);
1588       } catch (java.io.IOException e) {
1589         throw new com.google.protobuf.InvalidProtocolBufferException(
1590             e.getMessage()).setUnfinishedMessage(this);
1591       } finally {
1592         this.unknownFields = unknownFields.build();
1593         makeExtensionsImmutable();
1594       }
1595     }
1596     public static final com.google.protobuf.Descriptors.Descriptor
1597         getDescriptor() {
1598       return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1599     }
1600
1601     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1602         internalGetFieldAccessorTable() {
1603       return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_fieldAccessorTable
1604           .ensureFieldAccessorsInitialized(
1605               com.openxc.BinaryMessages.RawMessage.class, com.openxc.BinaryMessages.RawMessage.Builder.class);
1606     }
1607
1608     public static com.google.protobuf.Parser<RawMessage> PARSER =
1609         new com.google.protobuf.AbstractParser<RawMessage>() {
1610       public RawMessage parsePartialFrom(
1611           com.google.protobuf.CodedInputStream input,
1612           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1613           throws com.google.protobuf.InvalidProtocolBufferException {
1614         return new RawMessage(input, extensionRegistry);
1615       }
1616     };
1617
1618     @java.lang.Override
1619     public com.google.protobuf.Parser<RawMessage> getParserForType() {
1620       return PARSER;
1621     }
1622
1623     private int bitField0_;
1624     // optional int32 bus = 1;
1625     public static final int BUS_FIELD_NUMBER = 1;
1626     private int bus_;
1627     /**
1628      * <code>optional int32 bus = 1;</code>
1629      */
1630     public boolean hasBus() {
1631       return ((bitField0_ & 0x00000001) == 0x00000001);
1632     }
1633     /**
1634      * <code>optional int32 bus = 1;</code>
1635      */
1636     public int getBus() {
1637       return bus_;
1638     }
1639
1640     // optional uint32 message_id = 2;
1641     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
1642     private int messageId_;
1643     /**
1644      * <code>optional uint32 message_id = 2;</code>
1645      */
1646     public boolean hasMessageId() {
1647       return ((bitField0_ & 0x00000002) == 0x00000002);
1648     }
1649     /**
1650      * <code>optional uint32 message_id = 2;</code>
1651      */
1652     public int getMessageId() {
1653       return messageId_;
1654     }
1655
1656     // optional bytes data = 3;
1657     public static final int DATA_FIELD_NUMBER = 3;
1658     private com.google.protobuf.ByteString data_;
1659     /**
1660      * <code>optional bytes data = 3;</code>
1661      */
1662     public boolean hasData() {
1663       return ((bitField0_ & 0x00000004) == 0x00000004);
1664     }
1665     /**
1666      * <code>optional bytes data = 3;</code>
1667      */
1668     public com.google.protobuf.ByteString getData() {
1669       return data_;
1670     }
1671
1672     private void initFields() {
1673       bus_ = 0;
1674       messageId_ = 0;
1675       data_ = com.google.protobuf.ByteString.EMPTY;
1676     }
1677     private byte memoizedIsInitialized = -1;
1678     public final boolean isInitialized() {
1679       byte isInitialized = memoizedIsInitialized;
1680       if (isInitialized != -1) return isInitialized == 1;
1681
1682       memoizedIsInitialized = 1;
1683       return true;
1684     }
1685
1686     public void writeTo(com.google.protobuf.CodedOutputStream output)
1687                         throws java.io.IOException {
1688       getSerializedSize();
1689       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1690         output.writeInt32(1, bus_);
1691       }
1692       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1693         output.writeUInt32(2, messageId_);
1694       }
1695       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1696         output.writeBytes(3, data_);
1697       }
1698       getUnknownFields().writeTo(output);
1699     }
1700
1701     private int memoizedSerializedSize = -1;
1702     public int getSerializedSize() {
1703       int size = memoizedSerializedSize;
1704       if (size != -1) return size;
1705
1706       size = 0;
1707       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1708         size += com.google.protobuf.CodedOutputStream
1709           .computeInt32Size(1, bus_);
1710       }
1711       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1712         size += com.google.protobuf.CodedOutputStream
1713           .computeUInt32Size(2, messageId_);
1714       }
1715       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1716         size += com.google.protobuf.CodedOutputStream
1717           .computeBytesSize(3, data_);
1718       }
1719       size += getUnknownFields().getSerializedSize();
1720       memoizedSerializedSize = size;
1721       return size;
1722     }
1723
1724     private static final long serialVersionUID = 0L;
1725     @java.lang.Override
1726     protected java.lang.Object writeReplace()
1727         throws java.io.ObjectStreamException {
1728       return super.writeReplace();
1729     }
1730
1731     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1732         com.google.protobuf.ByteString data)
1733         throws com.google.protobuf.InvalidProtocolBufferException {
1734       return PARSER.parseFrom(data);
1735     }
1736     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1737         com.google.protobuf.ByteString data,
1738         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1739         throws com.google.protobuf.InvalidProtocolBufferException {
1740       return PARSER.parseFrom(data, extensionRegistry);
1741     }
1742     public static com.openxc.BinaryMessages.RawMessage parseFrom(byte[] data)
1743         throws com.google.protobuf.InvalidProtocolBufferException {
1744       return PARSER.parseFrom(data);
1745     }
1746     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1747         byte[] data,
1748         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1749         throws com.google.protobuf.InvalidProtocolBufferException {
1750       return PARSER.parseFrom(data, extensionRegistry);
1751     }
1752     public static com.openxc.BinaryMessages.RawMessage parseFrom(java.io.InputStream input)
1753         throws java.io.IOException {
1754       return PARSER.parseFrom(input);
1755     }
1756     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1757         java.io.InputStream input,
1758         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1759         throws java.io.IOException {
1760       return PARSER.parseFrom(input, extensionRegistry);
1761     }
1762     public static com.openxc.BinaryMessages.RawMessage parseDelimitedFrom(java.io.InputStream input)
1763         throws java.io.IOException {
1764       return PARSER.parseDelimitedFrom(input);
1765     }
1766     public static com.openxc.BinaryMessages.RawMessage parseDelimitedFrom(
1767         java.io.InputStream input,
1768         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1769         throws java.io.IOException {
1770       return PARSER.parseDelimitedFrom(input, extensionRegistry);
1771     }
1772     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1773         com.google.protobuf.CodedInputStream input)
1774         throws java.io.IOException {
1775       return PARSER.parseFrom(input);
1776     }
1777     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1778         com.google.protobuf.CodedInputStream input,
1779         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1780         throws java.io.IOException {
1781       return PARSER.parseFrom(input, extensionRegistry);
1782     }
1783
1784     public static Builder newBuilder() { return Builder.create(); }
1785     public Builder newBuilderForType() { return newBuilder(); }
1786     public static Builder newBuilder(com.openxc.BinaryMessages.RawMessage prototype) {
1787       return newBuilder().mergeFrom(prototype);
1788     }
1789     public Builder toBuilder() { return newBuilder(this); }
1790
1791     @java.lang.Override
1792     protected Builder newBuilderForType(
1793         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1794       Builder builder = new Builder(parent);
1795       return builder;
1796     }
1797     /**
1798      * Protobuf type {@code openxc.RawMessage}
1799      */
1800     public static final class Builder extends
1801         com.google.protobuf.GeneratedMessage.Builder<Builder>
1802        implements com.openxc.BinaryMessages.RawMessageOrBuilder {
1803       public static final com.google.protobuf.Descriptors.Descriptor
1804           getDescriptor() {
1805         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1806       }
1807
1808       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1809           internalGetFieldAccessorTable() {
1810         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_fieldAccessorTable
1811             .ensureFieldAccessorsInitialized(
1812                 com.openxc.BinaryMessages.RawMessage.class, com.openxc.BinaryMessages.RawMessage.Builder.class);
1813       }
1814
1815       // Construct using com.openxc.BinaryMessages.RawMessage.newBuilder()
1816       private Builder() {
1817         maybeForceBuilderInitialization();
1818       }
1819
1820       private Builder(
1821           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1822         super(parent);
1823         maybeForceBuilderInitialization();
1824       }
1825       private void maybeForceBuilderInitialization() {
1826         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
1827         }
1828       }
1829       private static Builder create() {
1830         return new Builder();
1831       }
1832
1833       public Builder clear() {
1834         super.clear();
1835         bus_ = 0;
1836         bitField0_ = (bitField0_ & ~0x00000001);
1837         messageId_ = 0;
1838         bitField0_ = (bitField0_ & ~0x00000002);
1839         data_ = com.google.protobuf.ByteString.EMPTY;
1840         bitField0_ = (bitField0_ & ~0x00000004);
1841         return this;
1842       }
1843
1844       public Builder clone() {
1845         return create().mergeFrom(buildPartial());
1846       }
1847
1848       public com.google.protobuf.Descriptors.Descriptor
1849           getDescriptorForType() {
1850         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1851       }
1852
1853       public com.openxc.BinaryMessages.RawMessage getDefaultInstanceForType() {
1854         return com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
1855       }
1856
1857       public com.openxc.BinaryMessages.RawMessage build() {
1858         com.openxc.BinaryMessages.RawMessage result = buildPartial();
1859         if (!result.isInitialized()) {
1860           throw newUninitializedMessageException(result);
1861         }
1862         return result;
1863       }
1864
1865       public com.openxc.BinaryMessages.RawMessage buildPartial() {
1866         com.openxc.BinaryMessages.RawMessage result = new com.openxc.BinaryMessages.RawMessage(this);
1867         int from_bitField0_ = bitField0_;
1868         int to_bitField0_ = 0;
1869         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
1870           to_bitField0_ |= 0x00000001;
1871         }
1872         result.bus_ = bus_;
1873         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
1874           to_bitField0_ |= 0x00000002;
1875         }
1876         result.messageId_ = messageId_;
1877         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
1878           to_bitField0_ |= 0x00000004;
1879         }
1880         result.data_ = data_;
1881         result.bitField0_ = to_bitField0_;
1882         onBuilt();
1883         return result;
1884       }
1885
1886       public Builder mergeFrom(com.google.protobuf.Message other) {
1887         if (other instanceof com.openxc.BinaryMessages.RawMessage) {
1888           return mergeFrom((com.openxc.BinaryMessages.RawMessage)other);
1889         } else {
1890           super.mergeFrom(other);
1891           return this;
1892         }
1893       }
1894
1895       public Builder mergeFrom(com.openxc.BinaryMessages.RawMessage other) {
1896         if (other == com.openxc.BinaryMessages.RawMessage.getDefaultInstance()) return this;
1897         if (other.hasBus()) {
1898           setBus(other.getBus());
1899         }
1900         if (other.hasMessageId()) {
1901           setMessageId(other.getMessageId());
1902         }
1903         if (other.hasData()) {
1904           setData(other.getData());
1905         }
1906         this.mergeUnknownFields(other.getUnknownFields());
1907         return this;
1908       }
1909
1910       public final boolean isInitialized() {
1911         return true;
1912       }
1913
1914       public Builder mergeFrom(
1915           com.google.protobuf.CodedInputStream input,
1916           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1917           throws java.io.IOException {
1918         com.openxc.BinaryMessages.RawMessage parsedMessage = null;
1919         try {
1920           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
1921         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1922           parsedMessage = (com.openxc.BinaryMessages.RawMessage) e.getUnfinishedMessage();
1923           throw e;
1924         } finally {
1925           if (parsedMessage != null) {
1926             mergeFrom(parsedMessage);
1927           }
1928         }
1929         return this;
1930       }
1931       private int bitField0_;
1932
1933       // optional int32 bus = 1;
1934       private int bus_ ;
1935       /**
1936        * <code>optional int32 bus = 1;</code>
1937        */
1938       public boolean hasBus() {
1939         return ((bitField0_ & 0x00000001) == 0x00000001);
1940       }
1941       /**
1942        * <code>optional int32 bus = 1;</code>
1943        */
1944       public int getBus() {
1945         return bus_;
1946       }
1947       /**
1948        * <code>optional int32 bus = 1;</code>
1949        */
1950       public Builder setBus(int value) {
1951         bitField0_ |= 0x00000001;
1952         bus_ = value;
1953         onChanged();
1954         return this;
1955       }
1956       /**
1957        * <code>optional int32 bus = 1;</code>
1958        */
1959       public Builder clearBus() {
1960         bitField0_ = (bitField0_ & ~0x00000001);
1961         bus_ = 0;
1962         onChanged();
1963         return this;
1964       }
1965
1966       // optional uint32 message_id = 2;
1967       private int messageId_ ;
1968       /**
1969        * <code>optional uint32 message_id = 2;</code>
1970        */
1971       public boolean hasMessageId() {
1972         return ((bitField0_ & 0x00000002) == 0x00000002);
1973       }
1974       /**
1975        * <code>optional uint32 message_id = 2;</code>
1976        */
1977       public int getMessageId() {
1978         return messageId_;
1979       }
1980       /**
1981        * <code>optional uint32 message_id = 2;</code>
1982        */
1983       public Builder setMessageId(int value) {
1984         bitField0_ |= 0x00000002;
1985         messageId_ = value;
1986         onChanged();
1987         return this;
1988       }
1989       /**
1990        * <code>optional uint32 message_id = 2;</code>
1991        */
1992       public Builder clearMessageId() {
1993         bitField0_ = (bitField0_ & ~0x00000002);
1994         messageId_ = 0;
1995         onChanged();
1996         return this;
1997       }
1998
1999       // optional bytes data = 3;
2000       private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
2001       /**
2002        * <code>optional bytes data = 3;</code>
2003        */
2004       public boolean hasData() {
2005         return ((bitField0_ & 0x00000004) == 0x00000004);
2006       }
2007       /**
2008        * <code>optional bytes data = 3;</code>
2009        */
2010       public com.google.protobuf.ByteString getData() {
2011         return data_;
2012       }
2013       /**
2014        * <code>optional bytes data = 3;</code>
2015        */
2016       public Builder setData(com.google.protobuf.ByteString value) {
2017         if (value == null) {
2018     throw new NullPointerException();
2019   }
2020   bitField0_ |= 0x00000004;
2021         data_ = value;
2022         onChanged();
2023         return this;
2024       }
2025       /**
2026        * <code>optional bytes data = 3;</code>
2027        */
2028       public Builder clearData() {
2029         bitField0_ = (bitField0_ & ~0x00000004);
2030         data_ = getDefaultInstance().getData();
2031         onChanged();
2032         return this;
2033       }
2034
2035       // @@protoc_insertion_point(builder_scope:openxc.RawMessage)
2036     }
2037
2038     static {
2039       defaultInstance = new RawMessage(true);
2040       defaultInstance.initFields();
2041     }
2042
2043     // @@protoc_insertion_point(class_scope:openxc.RawMessage)
2044   }
2045
2046   public interface ControlCommandOrBuilder
2047       extends com.google.protobuf.MessageOrBuilder {
2048
2049     // optional .openxc.ControlCommand.Type type = 1;
2050     /**
2051      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2052      */
2053     boolean hasType();
2054     /**
2055      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2056      */
2057     com.openxc.BinaryMessages.ControlCommand.Type getType();
2058
2059     // optional .openxc.DiagnosticRequest diagnostic_request = 2;
2060     /**
2061      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2062      */
2063     boolean hasDiagnosticRequest();
2064     /**
2065      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2066      */
2067     com.openxc.BinaryMessages.DiagnosticRequest getDiagnosticRequest();
2068     /**
2069      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2070      */
2071     com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getDiagnosticRequestOrBuilder();
2072   }
2073   /**
2074    * Protobuf type {@code openxc.ControlCommand}
2075    */
2076   public static final class ControlCommand extends
2077       com.google.protobuf.GeneratedMessage
2078       implements ControlCommandOrBuilder {
2079     // Use ControlCommand.newBuilder() to construct.
2080     private ControlCommand(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
2081       super(builder);
2082       this.unknownFields = builder.getUnknownFields();
2083     }
2084     private ControlCommand(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
2085
2086     private static final ControlCommand defaultInstance;
2087     public static ControlCommand getDefaultInstance() {
2088       return defaultInstance;
2089     }
2090
2091     public ControlCommand getDefaultInstanceForType() {
2092       return defaultInstance;
2093     }
2094
2095     private final com.google.protobuf.UnknownFieldSet unknownFields;
2096     @java.lang.Override
2097     public final com.google.protobuf.UnknownFieldSet
2098         getUnknownFields() {
2099       return this.unknownFields;
2100     }
2101     private ControlCommand(
2102         com.google.protobuf.CodedInputStream input,
2103         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2104         throws com.google.protobuf.InvalidProtocolBufferException {
2105       initFields();
2106       int mutable_bitField0_ = 0;
2107       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
2108           com.google.protobuf.UnknownFieldSet.newBuilder();
2109       try {
2110         boolean done = false;
2111         while (!done) {
2112           int tag = input.readTag();
2113           switch (tag) {
2114             case 0:
2115               done = true;
2116               break;
2117             default: {
2118               if (!parseUnknownField(input, unknownFields,
2119                                      extensionRegistry, tag)) {
2120                 done = true;
2121               }
2122               break;
2123             }
2124             case 8: {
2125               int rawValue = input.readEnum();
2126               com.openxc.BinaryMessages.ControlCommand.Type value = com.openxc.BinaryMessages.ControlCommand.Type.valueOf(rawValue);
2127               if (value == null) {
2128                 unknownFields.mergeVarintField(1, rawValue);
2129               } else {
2130                 bitField0_ |= 0x00000001;
2131                 type_ = value;
2132               }
2133               break;
2134             }
2135             case 18: {
2136               com.openxc.BinaryMessages.DiagnosticRequest.Builder subBuilder = null;
2137               if (((bitField0_ & 0x00000002) == 0x00000002)) {
2138                 subBuilder = diagnosticRequest_.toBuilder();
2139               }
2140               diagnosticRequest_ = input.readMessage(com.openxc.BinaryMessages.DiagnosticRequest.PARSER, extensionRegistry);
2141               if (subBuilder != null) {
2142                 subBuilder.mergeFrom(diagnosticRequest_);
2143                 diagnosticRequest_ = subBuilder.buildPartial();
2144               }
2145               bitField0_ |= 0x00000002;
2146               break;
2147             }
2148           }
2149         }
2150       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2151         throw e.setUnfinishedMessage(this);
2152       } catch (java.io.IOException e) {
2153         throw new com.google.protobuf.InvalidProtocolBufferException(
2154             e.getMessage()).setUnfinishedMessage(this);
2155       } finally {
2156         this.unknownFields = unknownFields.build();
2157         makeExtensionsImmutable();
2158       }
2159     }
2160     public static final com.google.protobuf.Descriptors.Descriptor
2161         getDescriptor() {
2162       return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
2163     }
2164
2165     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2166         internalGetFieldAccessorTable() {
2167       return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_fieldAccessorTable
2168           .ensureFieldAccessorsInitialized(
2169               com.openxc.BinaryMessages.ControlCommand.class, com.openxc.BinaryMessages.ControlCommand.Builder.class);
2170     }
2171
2172     public static com.google.protobuf.Parser<ControlCommand> PARSER =
2173         new com.google.protobuf.AbstractParser<ControlCommand>() {
2174       public ControlCommand parsePartialFrom(
2175           com.google.protobuf.CodedInputStream input,
2176           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2177           throws com.google.protobuf.InvalidProtocolBufferException {
2178         return new ControlCommand(input, extensionRegistry);
2179       }
2180     };
2181
2182     @java.lang.Override
2183     public com.google.protobuf.Parser<ControlCommand> getParserForType() {
2184       return PARSER;
2185     }
2186
2187     /**
2188      * Protobuf enum {@code openxc.ControlCommand.Type}
2189      */
2190     public enum Type
2191         implements com.google.protobuf.ProtocolMessageEnum {
2192       /**
2193        * <code>VERSION = 1;</code>
2194        */
2195       VERSION(0, 1),
2196       /**
2197        * <code>DEVICE_ID = 2;</code>
2198        */
2199       DEVICE_ID(1, 2),
2200       /**
2201        * <code>DIAGNOSTIC = 3;</code>
2202        */
2203       DIAGNOSTIC(2, 3),
2204       ;
2205
2206       /**
2207        * <code>VERSION = 1;</code>
2208        */
2209       public static final int VERSION_VALUE = 1;
2210       /**
2211        * <code>DEVICE_ID = 2;</code>
2212        */
2213       public static final int DEVICE_ID_VALUE = 2;
2214       /**
2215        * <code>DIAGNOSTIC = 3;</code>
2216        */
2217       public static final int DIAGNOSTIC_VALUE = 3;
2218
2219
2220       public final int getNumber() { return value; }
2221
2222       public static Type valueOf(int value) {
2223         switch (value) {
2224           case 1: return VERSION;
2225           case 2: return DEVICE_ID;
2226           case 3: return DIAGNOSTIC;
2227           default: return null;
2228         }
2229       }
2230
2231       public static com.google.protobuf.Internal.EnumLiteMap<Type>
2232           internalGetValueMap() {
2233         return internalValueMap;
2234       }
2235       private static com.google.protobuf.Internal.EnumLiteMap<Type>
2236           internalValueMap =
2237             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
2238               public Type findValueByNumber(int number) {
2239                 return Type.valueOf(number);
2240               }
2241             };
2242
2243       public final com.google.protobuf.Descriptors.EnumValueDescriptor
2244           getValueDescriptor() {
2245         return getDescriptor().getValues().get(index);
2246       }
2247       public final com.google.protobuf.Descriptors.EnumDescriptor
2248           getDescriptorForType() {
2249         return getDescriptor();
2250       }
2251       public static final com.google.protobuf.Descriptors.EnumDescriptor
2252           getDescriptor() {
2253         return com.openxc.BinaryMessages.ControlCommand.getDescriptor().getEnumTypes().get(0);
2254       }
2255
2256       private static final Type[] VALUES = values();
2257
2258       public static Type valueOf(
2259           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
2260         if (desc.getType() != getDescriptor()) {
2261           throw new java.lang.IllegalArgumentException(
2262             "EnumValueDescriptor is not for this type.");
2263         }
2264         return VALUES[desc.getIndex()];
2265       }
2266
2267       private final int index;
2268       private final int value;
2269
2270       private Type(int index, int value) {
2271         this.index = index;
2272         this.value = value;
2273       }
2274
2275       // @@protoc_insertion_point(enum_scope:openxc.ControlCommand.Type)
2276     }
2277
2278     private int bitField0_;
2279     // optional .openxc.ControlCommand.Type type = 1;
2280     public static final int TYPE_FIELD_NUMBER = 1;
2281     private com.openxc.BinaryMessages.ControlCommand.Type type_;
2282     /**
2283      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2284      */
2285     public boolean hasType() {
2286       return ((bitField0_ & 0x00000001) == 0x00000001);
2287     }
2288     /**
2289      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2290      */
2291     public com.openxc.BinaryMessages.ControlCommand.Type getType() {
2292       return type_;
2293     }
2294
2295     // optional .openxc.DiagnosticRequest diagnostic_request = 2;
2296     public static final int DIAGNOSTIC_REQUEST_FIELD_NUMBER = 2;
2297     private com.openxc.BinaryMessages.DiagnosticRequest diagnosticRequest_;
2298     /**
2299      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2300      */
2301     public boolean hasDiagnosticRequest() {
2302       return ((bitField0_ & 0x00000002) == 0x00000002);
2303     }
2304     /**
2305      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2306      */
2307     public com.openxc.BinaryMessages.DiagnosticRequest getDiagnosticRequest() {
2308       return diagnosticRequest_;
2309     }
2310     /**
2311      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2312      */
2313     public com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getDiagnosticRequestOrBuilder() {
2314       return diagnosticRequest_;
2315     }
2316
2317     private void initFields() {
2318       type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2319       diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
2320     }
2321     private byte memoizedIsInitialized = -1;
2322     public final boolean isInitialized() {
2323       byte isInitialized = memoizedIsInitialized;
2324       if (isInitialized != -1) return isInitialized == 1;
2325
2326       memoizedIsInitialized = 1;
2327       return true;
2328     }
2329
2330     public void writeTo(com.google.protobuf.CodedOutputStream output)
2331                         throws java.io.IOException {
2332       getSerializedSize();
2333       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2334         output.writeEnum(1, type_.getNumber());
2335       }
2336       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2337         output.writeMessage(2, diagnosticRequest_);
2338       }
2339       getUnknownFields().writeTo(output);
2340     }
2341
2342     private int memoizedSerializedSize = -1;
2343     public int getSerializedSize() {
2344       int size = memoizedSerializedSize;
2345       if (size != -1) return size;
2346
2347       size = 0;
2348       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2349         size += com.google.protobuf.CodedOutputStream
2350           .computeEnumSize(1, type_.getNumber());
2351       }
2352       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2353         size += com.google.protobuf.CodedOutputStream
2354           .computeMessageSize(2, diagnosticRequest_);
2355       }
2356       size += getUnknownFields().getSerializedSize();
2357       memoizedSerializedSize = size;
2358       return size;
2359     }
2360
2361     private static final long serialVersionUID = 0L;
2362     @java.lang.Override
2363     protected java.lang.Object writeReplace()
2364         throws java.io.ObjectStreamException {
2365       return super.writeReplace();
2366     }
2367
2368     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2369         com.google.protobuf.ByteString data)
2370         throws com.google.protobuf.InvalidProtocolBufferException {
2371       return PARSER.parseFrom(data);
2372     }
2373     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2374         com.google.protobuf.ByteString data,
2375         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2376         throws com.google.protobuf.InvalidProtocolBufferException {
2377       return PARSER.parseFrom(data, extensionRegistry);
2378     }
2379     public static com.openxc.BinaryMessages.ControlCommand parseFrom(byte[] data)
2380         throws com.google.protobuf.InvalidProtocolBufferException {
2381       return PARSER.parseFrom(data);
2382     }
2383     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2384         byte[] data,
2385         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2386         throws com.google.protobuf.InvalidProtocolBufferException {
2387       return PARSER.parseFrom(data, extensionRegistry);
2388     }
2389     public static com.openxc.BinaryMessages.ControlCommand parseFrom(java.io.InputStream input)
2390         throws java.io.IOException {
2391       return PARSER.parseFrom(input);
2392     }
2393     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2394         java.io.InputStream input,
2395         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2396         throws java.io.IOException {
2397       return PARSER.parseFrom(input, extensionRegistry);
2398     }
2399     public static com.openxc.BinaryMessages.ControlCommand parseDelimitedFrom(java.io.InputStream input)
2400         throws java.io.IOException {
2401       return PARSER.parseDelimitedFrom(input);
2402     }
2403     public static com.openxc.BinaryMessages.ControlCommand parseDelimitedFrom(
2404         java.io.InputStream input,
2405         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2406         throws java.io.IOException {
2407       return PARSER.parseDelimitedFrom(input, extensionRegistry);
2408     }
2409     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2410         com.google.protobuf.CodedInputStream input)
2411         throws java.io.IOException {
2412       return PARSER.parseFrom(input);
2413     }
2414     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2415         com.google.protobuf.CodedInputStream input,
2416         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2417         throws java.io.IOException {
2418       return PARSER.parseFrom(input, extensionRegistry);
2419     }
2420
2421     public static Builder newBuilder() { return Builder.create(); }
2422     public Builder newBuilderForType() { return newBuilder(); }
2423     public static Builder newBuilder(com.openxc.BinaryMessages.ControlCommand prototype) {
2424       return newBuilder().mergeFrom(prototype);
2425     }
2426     public Builder toBuilder() { return newBuilder(this); }
2427
2428     @java.lang.Override
2429     protected Builder newBuilderForType(
2430         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2431       Builder builder = new Builder(parent);
2432       return builder;
2433     }
2434     /**
2435      * Protobuf type {@code openxc.ControlCommand}
2436      */
2437     public static final class Builder extends
2438         com.google.protobuf.GeneratedMessage.Builder<Builder>
2439        implements com.openxc.BinaryMessages.ControlCommandOrBuilder {
2440       public static final com.google.protobuf.Descriptors.Descriptor
2441           getDescriptor() {
2442         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
2443       }
2444
2445       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2446           internalGetFieldAccessorTable() {
2447         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_fieldAccessorTable
2448             .ensureFieldAccessorsInitialized(
2449                 com.openxc.BinaryMessages.ControlCommand.class, com.openxc.BinaryMessages.ControlCommand.Builder.class);
2450       }
2451
2452       // Construct using com.openxc.BinaryMessages.ControlCommand.newBuilder()
2453       private Builder() {
2454         maybeForceBuilderInitialization();
2455       }
2456
2457       private Builder(
2458           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2459         super(parent);
2460         maybeForceBuilderInitialization();
2461       }
2462       private void maybeForceBuilderInitialization() {
2463         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2464           getDiagnosticRequestFieldBuilder();
2465         }
2466       }
2467       private static Builder create() {
2468         return new Builder();
2469       }
2470
2471       public Builder clear() {
2472         super.clear();
2473         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2474         bitField0_ = (bitField0_ & ~0x00000001);
2475         if (diagnosticRequestBuilder_ == null) {
2476           diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
2477         } else {
2478           diagnosticRequestBuilder_.clear();
2479         }
2480         bitField0_ = (bitField0_ & ~0x00000002);
2481         return this;
2482       }
2483
2484       public Builder clone() {
2485         return create().mergeFrom(buildPartial());
2486       }
2487
2488       public com.google.protobuf.Descriptors.Descriptor
2489           getDescriptorForType() {
2490         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
2491       }
2492
2493       public com.openxc.BinaryMessages.ControlCommand getDefaultInstanceForType() {
2494         return com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
2495       }
2496
2497       public com.openxc.BinaryMessages.ControlCommand build() {
2498         com.openxc.BinaryMessages.ControlCommand result = buildPartial();
2499         if (!result.isInitialized()) {
2500           throw newUninitializedMessageException(result);
2501         }
2502         return result;
2503       }
2504
2505       public com.openxc.BinaryMessages.ControlCommand buildPartial() {
2506         com.openxc.BinaryMessages.ControlCommand result = new com.openxc.BinaryMessages.ControlCommand(this);
2507         int from_bitField0_ = bitField0_;
2508         int to_bitField0_ = 0;
2509         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
2510           to_bitField0_ |= 0x00000001;
2511         }
2512         result.type_ = type_;
2513         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
2514           to_bitField0_ |= 0x00000002;
2515         }
2516         if (diagnosticRequestBuilder_ == null) {
2517           result.diagnosticRequest_ = diagnosticRequest_;
2518         } else {
2519           result.diagnosticRequest_ = diagnosticRequestBuilder_.build();
2520         }
2521         result.bitField0_ = to_bitField0_;
2522         onBuilt();
2523         return result;
2524       }
2525
2526       public Builder mergeFrom(com.google.protobuf.Message other) {
2527         if (other instanceof com.openxc.BinaryMessages.ControlCommand) {
2528           return mergeFrom((com.openxc.BinaryMessages.ControlCommand)other);
2529         } else {
2530           super.mergeFrom(other);
2531           return this;
2532         }
2533       }
2534
2535       public Builder mergeFrom(com.openxc.BinaryMessages.ControlCommand other) {
2536         if (other == com.openxc.BinaryMessages.ControlCommand.getDefaultInstance()) return this;
2537         if (other.hasType()) {
2538           setType(other.getType());
2539         }
2540         if (other.hasDiagnosticRequest()) {
2541           mergeDiagnosticRequest(other.getDiagnosticRequest());
2542         }
2543         this.mergeUnknownFields(other.getUnknownFields());
2544         return this;
2545       }
2546
2547       public final boolean isInitialized() {
2548         return true;
2549       }
2550
2551       public Builder mergeFrom(
2552           com.google.protobuf.CodedInputStream input,
2553           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2554           throws java.io.IOException {
2555         com.openxc.BinaryMessages.ControlCommand parsedMessage = null;
2556         try {
2557           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
2558         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2559           parsedMessage = (com.openxc.BinaryMessages.ControlCommand) e.getUnfinishedMessage();
2560           throw e;
2561         } finally {
2562           if (parsedMessage != null) {
2563             mergeFrom(parsedMessage);
2564           }
2565         }
2566         return this;
2567       }
2568       private int bitField0_;
2569
2570       // optional .openxc.ControlCommand.Type type = 1;
2571       private com.openxc.BinaryMessages.ControlCommand.Type type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2572       /**
2573        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2574        */
2575       public boolean hasType() {
2576         return ((bitField0_ & 0x00000001) == 0x00000001);
2577       }
2578       /**
2579        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2580        */
2581       public com.openxc.BinaryMessages.ControlCommand.Type getType() {
2582         return type_;
2583       }
2584       /**
2585        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2586        */
2587       public Builder setType(com.openxc.BinaryMessages.ControlCommand.Type value) {
2588         if (value == null) {
2589           throw new NullPointerException();
2590         }
2591         bitField0_ |= 0x00000001;
2592         type_ = value;
2593         onChanged();
2594         return this;
2595       }
2596       /**
2597        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2598        */
2599       public Builder clearType() {
2600         bitField0_ = (bitField0_ & ~0x00000001);
2601         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2602         onChanged();
2603         return this;
2604       }
2605
2606       // optional .openxc.DiagnosticRequest diagnostic_request = 2;
2607       private com.openxc.BinaryMessages.DiagnosticRequest diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
2608       private com.google.protobuf.SingleFieldBuilder<
2609           com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder> diagnosticRequestBuilder_;
2610       /**
2611        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2612        */
2613       public boolean hasDiagnosticRequest() {
2614         return ((bitField0_ & 0x00000002) == 0x00000002);
2615       }
2616       /**
2617        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2618        */
2619       public com.openxc.BinaryMessages.DiagnosticRequest getDiagnosticRequest() {
2620         if (diagnosticRequestBuilder_ == null) {
2621           return diagnosticRequest_;
2622         } else {
2623           return diagnosticRequestBuilder_.getMessage();
2624         }
2625       }
2626       /**
2627        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2628        */
2629       public Builder setDiagnosticRequest(com.openxc.BinaryMessages.DiagnosticRequest value) {
2630         if (diagnosticRequestBuilder_ == null) {
2631           if (value == null) {
2632             throw new NullPointerException();
2633           }
2634           diagnosticRequest_ = value;
2635           onChanged();
2636         } else {
2637           diagnosticRequestBuilder_.setMessage(value);
2638         }
2639         bitField0_ |= 0x00000002;
2640         return this;
2641       }
2642       /**
2643        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2644        */
2645       public Builder setDiagnosticRequest(
2646           com.openxc.BinaryMessages.DiagnosticRequest.Builder builderForValue) {
2647         if (diagnosticRequestBuilder_ == null) {
2648           diagnosticRequest_ = builderForValue.build();
2649           onChanged();
2650         } else {
2651           diagnosticRequestBuilder_.setMessage(builderForValue.build());
2652         }
2653         bitField0_ |= 0x00000002;
2654         return this;
2655       }
2656       /**
2657        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2658        */
2659       public Builder mergeDiagnosticRequest(com.openxc.BinaryMessages.DiagnosticRequest value) {
2660         if (diagnosticRequestBuilder_ == null) {
2661           if (((bitField0_ & 0x00000002) == 0x00000002) &&
2662               diagnosticRequest_ != com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance()) {
2663             diagnosticRequest_ =
2664               com.openxc.BinaryMessages.DiagnosticRequest.newBuilder(diagnosticRequest_).mergeFrom(value).buildPartial();
2665           } else {
2666             diagnosticRequest_ = value;
2667           }
2668           onChanged();
2669         } else {
2670           diagnosticRequestBuilder_.mergeFrom(value);
2671         }
2672         bitField0_ |= 0x00000002;
2673         return this;
2674       }
2675       /**
2676        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2677        */
2678       public Builder clearDiagnosticRequest() {
2679         if (diagnosticRequestBuilder_ == null) {
2680           diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
2681           onChanged();
2682         } else {
2683           diagnosticRequestBuilder_.clear();
2684         }
2685         bitField0_ = (bitField0_ & ~0x00000002);
2686         return this;
2687       }
2688       /**
2689        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2690        */
2691       public com.openxc.BinaryMessages.DiagnosticRequest.Builder getDiagnosticRequestBuilder() {
2692         bitField0_ |= 0x00000002;
2693         onChanged();
2694         return getDiagnosticRequestFieldBuilder().getBuilder();
2695       }
2696       /**
2697        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2698        */
2699       public com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getDiagnosticRequestOrBuilder() {
2700         if (diagnosticRequestBuilder_ != null) {
2701           return diagnosticRequestBuilder_.getMessageOrBuilder();
2702         } else {
2703           return diagnosticRequest_;
2704         }
2705       }
2706       /**
2707        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2708        */
2709       private com.google.protobuf.SingleFieldBuilder<
2710           com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder> 
2711           getDiagnosticRequestFieldBuilder() {
2712         if (diagnosticRequestBuilder_ == null) {
2713           diagnosticRequestBuilder_ = new com.google.protobuf.SingleFieldBuilder<
2714               com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder>(
2715                   diagnosticRequest_,
2716                   getParentForChildren(),
2717                   isClean());
2718           diagnosticRequest_ = null;
2719         }
2720         return diagnosticRequestBuilder_;
2721       }
2722
2723       // @@protoc_insertion_point(builder_scope:openxc.ControlCommand)
2724     }
2725
2726     static {
2727       defaultInstance = new ControlCommand(true);
2728       defaultInstance.initFields();
2729     }
2730
2731     // @@protoc_insertion_point(class_scope:openxc.ControlCommand)
2732   }
2733
2734   public interface CommandResponseOrBuilder
2735       extends com.google.protobuf.MessageOrBuilder {
2736
2737     // optional .openxc.ControlCommand.Type type = 1;
2738     /**
2739      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2740      */
2741     boolean hasType();
2742     /**
2743      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2744      */
2745     com.openxc.BinaryMessages.ControlCommand.Type getType();
2746
2747     // optional string message = 2;
2748     /**
2749      * <code>optional string message = 2;</code>
2750      */
2751     boolean hasMessage();
2752     /**
2753      * <code>optional string message = 2;</code>
2754      */
2755     java.lang.String getMessage();
2756     /**
2757      * <code>optional string message = 2;</code>
2758      */
2759     com.google.protobuf.ByteString
2760         getMessageBytes();
2761   }
2762   /**
2763    * Protobuf type {@code openxc.CommandResponse}
2764    */
2765   public static final class CommandResponse extends
2766       com.google.protobuf.GeneratedMessage
2767       implements CommandResponseOrBuilder {
2768     // Use CommandResponse.newBuilder() to construct.
2769     private CommandResponse(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
2770       super(builder);
2771       this.unknownFields = builder.getUnknownFields();
2772     }
2773     private CommandResponse(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
2774
2775     private static final CommandResponse defaultInstance;
2776     public static CommandResponse getDefaultInstance() {
2777       return defaultInstance;
2778     }
2779
2780     public CommandResponse getDefaultInstanceForType() {
2781       return defaultInstance;
2782     }
2783
2784     private final com.google.protobuf.UnknownFieldSet unknownFields;
2785     @java.lang.Override
2786     public final com.google.protobuf.UnknownFieldSet
2787         getUnknownFields() {
2788       return this.unknownFields;
2789     }
2790     private CommandResponse(
2791         com.google.protobuf.CodedInputStream input,
2792         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2793         throws com.google.protobuf.InvalidProtocolBufferException {
2794       initFields();
2795       int mutable_bitField0_ = 0;
2796       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
2797           com.google.protobuf.UnknownFieldSet.newBuilder();
2798       try {
2799         boolean done = false;
2800         while (!done) {
2801           int tag = input.readTag();
2802           switch (tag) {
2803             case 0:
2804               done = true;
2805               break;
2806             default: {
2807               if (!parseUnknownField(input, unknownFields,
2808                                      extensionRegistry, tag)) {
2809                 done = true;
2810               }
2811               break;
2812             }
2813             case 8: {
2814               int rawValue = input.readEnum();
2815               com.openxc.BinaryMessages.ControlCommand.Type value = com.openxc.BinaryMessages.ControlCommand.Type.valueOf(rawValue);
2816               if (value == null) {
2817                 unknownFields.mergeVarintField(1, rawValue);
2818               } else {
2819                 bitField0_ |= 0x00000001;
2820                 type_ = value;
2821               }
2822               break;
2823             }
2824             case 18: {
2825               bitField0_ |= 0x00000002;
2826               message_ = input.readBytes();
2827               break;
2828             }
2829           }
2830         }
2831       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2832         throw e.setUnfinishedMessage(this);
2833       } catch (java.io.IOException e) {
2834         throw new com.google.protobuf.InvalidProtocolBufferException(
2835             e.getMessage()).setUnfinishedMessage(this);
2836       } finally {
2837         this.unknownFields = unknownFields.build();
2838         makeExtensionsImmutable();
2839       }
2840     }
2841     public static final com.google.protobuf.Descriptors.Descriptor
2842         getDescriptor() {
2843       return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
2844     }
2845
2846     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2847         internalGetFieldAccessorTable() {
2848       return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_fieldAccessorTable
2849           .ensureFieldAccessorsInitialized(
2850               com.openxc.BinaryMessages.CommandResponse.class, com.openxc.BinaryMessages.CommandResponse.Builder.class);
2851     }
2852
2853     public static com.google.protobuf.Parser<CommandResponse> PARSER =
2854         new com.google.protobuf.AbstractParser<CommandResponse>() {
2855       public CommandResponse parsePartialFrom(
2856           com.google.protobuf.CodedInputStream input,
2857           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2858           throws com.google.protobuf.InvalidProtocolBufferException {
2859         return new CommandResponse(input, extensionRegistry);
2860       }
2861     };
2862
2863     @java.lang.Override
2864     public com.google.protobuf.Parser<CommandResponse> getParserForType() {
2865       return PARSER;
2866     }
2867
2868     private int bitField0_;
2869     // optional .openxc.ControlCommand.Type type = 1;
2870     public static final int TYPE_FIELD_NUMBER = 1;
2871     private com.openxc.BinaryMessages.ControlCommand.Type type_;
2872     /**
2873      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2874      */
2875     public boolean hasType() {
2876       return ((bitField0_ & 0x00000001) == 0x00000001);
2877     }
2878     /**
2879      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2880      */
2881     public com.openxc.BinaryMessages.ControlCommand.Type getType() {
2882       return type_;
2883     }
2884
2885     // optional string message = 2;
2886     public static final int MESSAGE_FIELD_NUMBER = 2;
2887     private java.lang.Object message_;
2888     /**
2889      * <code>optional string message = 2;</code>
2890      */
2891     public boolean hasMessage() {
2892       return ((bitField0_ & 0x00000002) == 0x00000002);
2893     }
2894     /**
2895      * <code>optional string message = 2;</code>
2896      */
2897     public java.lang.String getMessage() {
2898       java.lang.Object ref = message_;
2899       if (ref instanceof java.lang.String) {
2900         return (java.lang.String) ref;
2901       } else {
2902         com.google.protobuf.ByteString bs = 
2903             (com.google.protobuf.ByteString) ref;
2904         java.lang.String s = bs.toStringUtf8();
2905         if (bs.isValidUtf8()) {
2906           message_ = s;
2907         }
2908         return s;
2909       }
2910     }
2911     /**
2912      * <code>optional string message = 2;</code>
2913      */
2914     public com.google.protobuf.ByteString
2915         getMessageBytes() {
2916       java.lang.Object ref = message_;
2917       if (ref instanceof java.lang.String) {
2918         com.google.protobuf.ByteString b = 
2919             com.google.protobuf.ByteString.copyFromUtf8(
2920                 (java.lang.String) ref);
2921         message_ = b;
2922         return b;
2923       } else {
2924         return (com.google.protobuf.ByteString) ref;
2925       }
2926     }
2927
2928     private void initFields() {
2929       type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2930       message_ = "";
2931     }
2932     private byte memoizedIsInitialized = -1;
2933     public final boolean isInitialized() {
2934       byte isInitialized = memoizedIsInitialized;
2935       if (isInitialized != -1) return isInitialized == 1;
2936
2937       memoizedIsInitialized = 1;
2938       return true;
2939     }
2940
2941     public void writeTo(com.google.protobuf.CodedOutputStream output)
2942                         throws java.io.IOException {
2943       getSerializedSize();
2944       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2945         output.writeEnum(1, type_.getNumber());
2946       }
2947       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2948         output.writeBytes(2, getMessageBytes());
2949       }
2950       getUnknownFields().writeTo(output);
2951     }
2952
2953     private int memoizedSerializedSize = -1;
2954     public int getSerializedSize() {
2955       int size = memoizedSerializedSize;
2956       if (size != -1) return size;
2957
2958       size = 0;
2959       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2960         size += com.google.protobuf.CodedOutputStream
2961           .computeEnumSize(1, type_.getNumber());
2962       }
2963       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2964         size += com.google.protobuf.CodedOutputStream
2965           .computeBytesSize(2, getMessageBytes());
2966       }
2967       size += getUnknownFields().getSerializedSize();
2968       memoizedSerializedSize = size;
2969       return size;
2970     }
2971
2972     private static final long serialVersionUID = 0L;
2973     @java.lang.Override
2974     protected java.lang.Object writeReplace()
2975         throws java.io.ObjectStreamException {
2976       return super.writeReplace();
2977     }
2978
2979     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
2980         com.google.protobuf.ByteString data)
2981         throws com.google.protobuf.InvalidProtocolBufferException {
2982       return PARSER.parseFrom(data);
2983     }
2984     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
2985         com.google.protobuf.ByteString data,
2986         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2987         throws com.google.protobuf.InvalidProtocolBufferException {
2988       return PARSER.parseFrom(data, extensionRegistry);
2989     }
2990     public static com.openxc.BinaryMessages.CommandResponse parseFrom(byte[] data)
2991         throws com.google.protobuf.InvalidProtocolBufferException {
2992       return PARSER.parseFrom(data);
2993     }
2994     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
2995         byte[] data,
2996         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2997         throws com.google.protobuf.InvalidProtocolBufferException {
2998       return PARSER.parseFrom(data, extensionRegistry);
2999     }
3000     public static com.openxc.BinaryMessages.CommandResponse parseFrom(java.io.InputStream input)
3001         throws java.io.IOException {
3002       return PARSER.parseFrom(input);
3003     }
3004     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3005         java.io.InputStream input,
3006         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3007         throws java.io.IOException {
3008       return PARSER.parseFrom(input, extensionRegistry);
3009     }
3010     public static com.openxc.BinaryMessages.CommandResponse parseDelimitedFrom(java.io.InputStream input)
3011         throws java.io.IOException {
3012       return PARSER.parseDelimitedFrom(input);
3013     }
3014     public static com.openxc.BinaryMessages.CommandResponse parseDelimitedFrom(
3015         java.io.InputStream input,
3016         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3017         throws java.io.IOException {
3018       return PARSER.parseDelimitedFrom(input, extensionRegistry);
3019     }
3020     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3021         com.google.protobuf.CodedInputStream input)
3022         throws java.io.IOException {
3023       return PARSER.parseFrom(input);
3024     }
3025     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3026         com.google.protobuf.CodedInputStream input,
3027         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3028         throws java.io.IOException {
3029       return PARSER.parseFrom(input, extensionRegistry);
3030     }
3031
3032     public static Builder newBuilder() { return Builder.create(); }
3033     public Builder newBuilderForType() { return newBuilder(); }
3034     public static Builder newBuilder(com.openxc.BinaryMessages.CommandResponse prototype) {
3035       return newBuilder().mergeFrom(prototype);
3036     }
3037     public Builder toBuilder() { return newBuilder(this); }
3038
3039     @java.lang.Override
3040     protected Builder newBuilderForType(
3041         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3042       Builder builder = new Builder(parent);
3043       return builder;
3044     }
3045     /**
3046      * Protobuf type {@code openxc.CommandResponse}
3047      */
3048     public static final class Builder extends
3049         com.google.protobuf.GeneratedMessage.Builder<Builder>
3050        implements com.openxc.BinaryMessages.CommandResponseOrBuilder {
3051       public static final com.google.protobuf.Descriptors.Descriptor
3052           getDescriptor() {
3053         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
3054       }
3055
3056       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3057           internalGetFieldAccessorTable() {
3058         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_fieldAccessorTable
3059             .ensureFieldAccessorsInitialized(
3060                 com.openxc.BinaryMessages.CommandResponse.class, com.openxc.BinaryMessages.CommandResponse.Builder.class);
3061       }
3062
3063       // Construct using com.openxc.BinaryMessages.CommandResponse.newBuilder()
3064       private Builder() {
3065         maybeForceBuilderInitialization();
3066       }
3067
3068       private Builder(
3069           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3070         super(parent);
3071         maybeForceBuilderInitialization();
3072       }
3073       private void maybeForceBuilderInitialization() {
3074         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
3075         }
3076       }
3077       private static Builder create() {
3078         return new Builder();
3079       }
3080
3081       public Builder clear() {
3082         super.clear();
3083         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
3084         bitField0_ = (bitField0_ & ~0x00000001);
3085         message_ = "";
3086         bitField0_ = (bitField0_ & ~0x00000002);
3087         return this;
3088       }
3089
3090       public Builder clone() {
3091         return create().mergeFrom(buildPartial());
3092       }
3093
3094       public com.google.protobuf.Descriptors.Descriptor
3095           getDescriptorForType() {
3096         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
3097       }
3098
3099       public com.openxc.BinaryMessages.CommandResponse getDefaultInstanceForType() {
3100         return com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
3101       }
3102
3103       public com.openxc.BinaryMessages.CommandResponse build() {
3104         com.openxc.BinaryMessages.CommandResponse result = buildPartial();
3105         if (!result.isInitialized()) {
3106           throw newUninitializedMessageException(result);
3107         }
3108         return result;
3109       }
3110
3111       public com.openxc.BinaryMessages.CommandResponse buildPartial() {
3112         com.openxc.BinaryMessages.CommandResponse result = new com.openxc.BinaryMessages.CommandResponse(this);
3113         int from_bitField0_ = bitField0_;
3114         int to_bitField0_ = 0;
3115         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
3116           to_bitField0_ |= 0x00000001;
3117         }
3118         result.type_ = type_;
3119         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
3120           to_bitField0_ |= 0x00000002;
3121         }
3122         result.message_ = message_;
3123         result.bitField0_ = to_bitField0_;
3124         onBuilt();
3125         return result;
3126       }
3127
3128       public Builder mergeFrom(com.google.protobuf.Message other) {
3129         if (other instanceof com.openxc.BinaryMessages.CommandResponse) {
3130           return mergeFrom((com.openxc.BinaryMessages.CommandResponse)other);
3131         } else {
3132           super.mergeFrom(other);
3133           return this;
3134         }
3135       }
3136
3137       public Builder mergeFrom(com.openxc.BinaryMessages.CommandResponse other) {
3138         if (other == com.openxc.BinaryMessages.CommandResponse.getDefaultInstance()) return this;
3139         if (other.hasType()) {
3140           setType(other.getType());
3141         }
3142         if (other.hasMessage()) {
3143           bitField0_ |= 0x00000002;
3144           message_ = other.message_;
3145           onChanged();
3146         }
3147         this.mergeUnknownFields(other.getUnknownFields());
3148         return this;
3149       }
3150
3151       public final boolean isInitialized() {
3152         return true;
3153       }
3154
3155       public Builder mergeFrom(
3156           com.google.protobuf.CodedInputStream input,
3157           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3158           throws java.io.IOException {
3159         com.openxc.BinaryMessages.CommandResponse parsedMessage = null;
3160         try {
3161           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
3162         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3163           parsedMessage = (com.openxc.BinaryMessages.CommandResponse) e.getUnfinishedMessage();
3164           throw e;
3165         } finally {
3166           if (parsedMessage != null) {
3167             mergeFrom(parsedMessage);
3168           }
3169         }
3170         return this;
3171       }
3172       private int bitField0_;
3173
3174       // optional .openxc.ControlCommand.Type type = 1;
3175       private com.openxc.BinaryMessages.ControlCommand.Type type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
3176       /**
3177        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3178        */
3179       public boolean hasType() {
3180         return ((bitField0_ & 0x00000001) == 0x00000001);
3181       }
3182       /**
3183        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3184        */
3185       public com.openxc.BinaryMessages.ControlCommand.Type getType() {
3186         return type_;
3187       }
3188       /**
3189        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3190        */
3191       public Builder setType(com.openxc.BinaryMessages.ControlCommand.Type value) {
3192         if (value == null) {
3193           throw new NullPointerException();
3194         }
3195         bitField0_ |= 0x00000001;
3196         type_ = value;
3197         onChanged();
3198         return this;
3199       }
3200       /**
3201        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3202        */
3203       public Builder clearType() {
3204         bitField0_ = (bitField0_ & ~0x00000001);
3205         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
3206         onChanged();
3207         return this;
3208       }
3209
3210       // optional string message = 2;
3211       private java.lang.Object message_ = "";
3212       /**
3213        * <code>optional string message = 2;</code>
3214        */
3215       public boolean hasMessage() {
3216         return ((bitField0_ & 0x00000002) == 0x00000002);
3217       }
3218       /**
3219        * <code>optional string message = 2;</code>
3220        */
3221       public java.lang.String getMessage() {
3222         java.lang.Object ref = message_;
3223         if (!(ref instanceof java.lang.String)) {
3224           java.lang.String s = ((com.google.protobuf.ByteString) ref)
3225               .toStringUtf8();
3226           message_ = s;
3227           return s;
3228         } else {
3229           return (java.lang.String) ref;
3230         }
3231       }
3232       /**
3233        * <code>optional string message = 2;</code>
3234        */
3235       public com.google.protobuf.ByteString
3236           getMessageBytes() {
3237         java.lang.Object ref = message_;
3238         if (ref instanceof String) {
3239           com.google.protobuf.ByteString b = 
3240               com.google.protobuf.ByteString.copyFromUtf8(
3241                   (java.lang.String) ref);
3242           message_ = b;
3243           return b;
3244         } else {
3245           return (com.google.protobuf.ByteString) ref;
3246         }
3247       }
3248       /**
3249        * <code>optional string message = 2;</code>
3250        */
3251       public Builder setMessage(
3252           java.lang.String value) {
3253         if (value == null) {
3254     throw new NullPointerException();
3255   }
3256   bitField0_ |= 0x00000002;
3257         message_ = value;
3258         onChanged();
3259         return this;
3260       }
3261       /**
3262        * <code>optional string message = 2;</code>
3263        */
3264       public Builder clearMessage() {
3265         bitField0_ = (bitField0_ & ~0x00000002);
3266         message_ = getDefaultInstance().getMessage();
3267         onChanged();
3268         return this;
3269       }
3270       /**
3271        * <code>optional string message = 2;</code>
3272        */
3273       public Builder setMessageBytes(
3274           com.google.protobuf.ByteString value) {
3275         if (value == null) {
3276     throw new NullPointerException();
3277   }
3278   bitField0_ |= 0x00000002;
3279         message_ = value;
3280         onChanged();
3281         return this;
3282       }
3283
3284       // @@protoc_insertion_point(builder_scope:openxc.CommandResponse)
3285     }
3286
3287     static {
3288       defaultInstance = new CommandResponse(true);
3289       defaultInstance.initFields();
3290     }
3291
3292     // @@protoc_insertion_point(class_scope:openxc.CommandResponse)
3293   }
3294
3295   public interface DiagnosticRequestOrBuilder
3296       extends com.google.protobuf.MessageOrBuilder {
3297
3298     // optional int32 bus = 1;
3299     /**
3300      * <code>optional int32 bus = 1;</code>
3301      */
3302     boolean hasBus();
3303     /**
3304      * <code>optional int32 bus = 1;</code>
3305      */
3306     int getBus();
3307
3308     // optional uint32 message_id = 2;
3309     /**
3310      * <code>optional uint32 message_id = 2;</code>
3311      */
3312     boolean hasMessageId();
3313     /**
3314      * <code>optional uint32 message_id = 2;</code>
3315      */
3316     int getMessageId();
3317
3318     // optional uint32 mode = 3;
3319     /**
3320      * <code>optional uint32 mode = 3;</code>
3321      */
3322     boolean hasMode();
3323     /**
3324      * <code>optional uint32 mode = 3;</code>
3325      */
3326     int getMode();
3327
3328     // optional uint32 pid = 4;
3329     /**
3330      * <code>optional uint32 pid = 4;</code>
3331      */
3332     boolean hasPid();
3333     /**
3334      * <code>optional uint32 pid = 4;</code>
3335      */
3336     int getPid();
3337
3338     // optional bytes payload = 5;
3339     /**
3340      * <code>optional bytes payload = 5;</code>
3341      *
3342      * <pre>
3343      * TODO we are capping this at 8 bytes for now - need to change when we
3344      * support multi-frame responses
3345      * </pre>
3346      */
3347     boolean hasPayload();
3348     /**
3349      * <code>optional bytes payload = 5;</code>
3350      *
3351      * <pre>
3352      * TODO we are capping this at 8 bytes for now - need to change when we
3353      * support multi-frame responses
3354      * </pre>
3355      */
3356     com.google.protobuf.ByteString getPayload();
3357
3358     // optional bool multiple_responses = 6;
3359     /**
3360      * <code>optional bool multiple_responses = 6;</code>
3361      */
3362     boolean hasMultipleResponses();
3363     /**
3364      * <code>optional bool multiple_responses = 6;</code>
3365      */
3366     boolean getMultipleResponses();
3367
3368     // optional double factor = 7;
3369     /**
3370      * <code>optional double factor = 7;</code>
3371      */
3372     boolean hasFactor();
3373     /**
3374      * <code>optional double factor = 7;</code>
3375      */
3376     double getFactor();
3377
3378     // optional double offset = 8;
3379     /**
3380      * <code>optional double offset = 8;</code>
3381      */
3382     boolean hasOffset();
3383     /**
3384      * <code>optional double offset = 8;</code>
3385      */
3386     double getOffset();
3387
3388     // optional double frequency = 9;
3389     /**
3390      * <code>optional double frequency = 9;</code>
3391      */
3392     boolean hasFrequency();
3393     /**
3394      * <code>optional double frequency = 9;</code>
3395      */
3396     double getFrequency();
3397
3398     // optional string name = 10;
3399     /**
3400      * <code>optional string name = 10;</code>
3401      */
3402     boolean hasName();
3403     /**
3404      * <code>optional string name = 10;</code>
3405      */
3406     java.lang.String getName();
3407     /**
3408      * <code>optional string name = 10;</code>
3409      */
3410     com.google.protobuf.ByteString
3411         getNameBytes();
3412   }
3413   /**
3414    * Protobuf type {@code openxc.DiagnosticRequest}
3415    */
3416   public static final class DiagnosticRequest extends
3417       com.google.protobuf.GeneratedMessage
3418       implements DiagnosticRequestOrBuilder {
3419     // Use DiagnosticRequest.newBuilder() to construct.
3420     private DiagnosticRequest(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
3421       super(builder);
3422       this.unknownFields = builder.getUnknownFields();
3423     }
3424     private DiagnosticRequest(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
3425
3426     private static final DiagnosticRequest defaultInstance;
3427     public static DiagnosticRequest getDefaultInstance() {
3428       return defaultInstance;
3429     }
3430
3431     public DiagnosticRequest getDefaultInstanceForType() {
3432       return defaultInstance;
3433     }
3434
3435     private final com.google.protobuf.UnknownFieldSet unknownFields;
3436     @java.lang.Override
3437     public final com.google.protobuf.UnknownFieldSet
3438         getUnknownFields() {
3439       return this.unknownFields;
3440     }
3441     private DiagnosticRequest(
3442         com.google.protobuf.CodedInputStream input,
3443         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3444         throws com.google.protobuf.InvalidProtocolBufferException {
3445       initFields();
3446       int mutable_bitField0_ = 0;
3447       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
3448           com.google.protobuf.UnknownFieldSet.newBuilder();
3449       try {
3450         boolean done = false;
3451         while (!done) {
3452           int tag = input.readTag();
3453           switch (tag) {
3454             case 0:
3455               done = true;
3456               break;
3457             default: {
3458               if (!parseUnknownField(input, unknownFields,
3459                                      extensionRegistry, tag)) {
3460                 done = true;
3461               }
3462               break;
3463             }
3464             case 8: {
3465               bitField0_ |= 0x00000001;
3466               bus_ = input.readInt32();
3467               break;
3468             }
3469             case 16: {
3470               bitField0_ |= 0x00000002;
3471               messageId_ = input.readUInt32();
3472               break;
3473             }
3474             case 24: {
3475               bitField0_ |= 0x00000004;
3476               mode_ = input.readUInt32();
3477               break;
3478             }
3479             case 32: {
3480               bitField0_ |= 0x00000008;
3481               pid_ = input.readUInt32();
3482               break;
3483             }
3484             case 42: {
3485               bitField0_ |= 0x00000010;
3486               payload_ = input.readBytes();
3487               break;
3488             }
3489             case 48: {
3490               bitField0_ |= 0x00000020;
3491               multipleResponses_ = input.readBool();
3492               break;
3493             }
3494             case 57: {
3495               bitField0_ |= 0x00000040;
3496               factor_ = input.readDouble();
3497               break;
3498             }
3499             case 65: {
3500               bitField0_ |= 0x00000080;
3501               offset_ = input.readDouble();
3502               break;
3503             }
3504             case 73: {
3505               bitField0_ |= 0x00000100;
3506               frequency_ = input.readDouble();
3507               break;
3508             }
3509             case 82: {
3510               bitField0_ |= 0x00000200;
3511               name_ = input.readBytes();
3512               break;
3513             }
3514           }
3515         }
3516       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3517         throw e.setUnfinishedMessage(this);
3518       } catch (java.io.IOException e) {
3519         throw new com.google.protobuf.InvalidProtocolBufferException(
3520             e.getMessage()).setUnfinishedMessage(this);
3521       } finally {
3522         this.unknownFields = unknownFields.build();
3523         makeExtensionsImmutable();
3524       }
3525     }
3526     public static final com.google.protobuf.Descriptors.Descriptor
3527         getDescriptor() {
3528       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
3529     }
3530
3531     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3532         internalGetFieldAccessorTable() {
3533       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_fieldAccessorTable
3534           .ensureFieldAccessorsInitialized(
3535               com.openxc.BinaryMessages.DiagnosticRequest.class, com.openxc.BinaryMessages.DiagnosticRequest.Builder.class);
3536     }
3537
3538     public static com.google.protobuf.Parser<DiagnosticRequest> PARSER =
3539         new com.google.protobuf.AbstractParser<DiagnosticRequest>() {
3540       public DiagnosticRequest parsePartialFrom(
3541           com.google.protobuf.CodedInputStream input,
3542           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3543           throws com.google.protobuf.InvalidProtocolBufferException {
3544         return new DiagnosticRequest(input, extensionRegistry);
3545       }
3546     };
3547
3548     @java.lang.Override
3549     public com.google.protobuf.Parser<DiagnosticRequest> getParserForType() {
3550       return PARSER;
3551     }
3552
3553     private int bitField0_;
3554     // optional int32 bus = 1;
3555     public static final int BUS_FIELD_NUMBER = 1;
3556     private int bus_;
3557     /**
3558      * <code>optional int32 bus = 1;</code>
3559      */
3560     public boolean hasBus() {
3561       return ((bitField0_ & 0x00000001) == 0x00000001);
3562     }
3563     /**
3564      * <code>optional int32 bus = 1;</code>
3565      */
3566     public int getBus() {
3567       return bus_;
3568     }
3569
3570     // optional uint32 message_id = 2;
3571     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
3572     private int messageId_;
3573     /**
3574      * <code>optional uint32 message_id = 2;</code>
3575      */
3576     public boolean hasMessageId() {
3577       return ((bitField0_ & 0x00000002) == 0x00000002);
3578     }
3579     /**
3580      * <code>optional uint32 message_id = 2;</code>
3581      */
3582     public int getMessageId() {
3583       return messageId_;
3584     }
3585
3586     // optional uint32 mode = 3;
3587     public static final int MODE_FIELD_NUMBER = 3;
3588     private int mode_;
3589     /**
3590      * <code>optional uint32 mode = 3;</code>
3591      */
3592     public boolean hasMode() {
3593       return ((bitField0_ & 0x00000004) == 0x00000004);
3594     }
3595     /**
3596      * <code>optional uint32 mode = 3;</code>
3597      */
3598     public int getMode() {
3599       return mode_;
3600     }
3601
3602     // optional uint32 pid = 4;
3603     public static final int PID_FIELD_NUMBER = 4;
3604     private int pid_;
3605     /**
3606      * <code>optional uint32 pid = 4;</code>
3607      */
3608     public boolean hasPid() {
3609       return ((bitField0_ & 0x00000008) == 0x00000008);
3610     }
3611     /**
3612      * <code>optional uint32 pid = 4;</code>
3613      */
3614     public int getPid() {
3615       return pid_;
3616     }
3617
3618     // optional bytes payload = 5;
3619     public static final int PAYLOAD_FIELD_NUMBER = 5;
3620     private com.google.protobuf.ByteString payload_;
3621     /**
3622      * <code>optional bytes payload = 5;</code>
3623      *
3624      * <pre>
3625      * TODO we are capping this at 8 bytes for now - need to change when we
3626      * support multi-frame responses
3627      * </pre>
3628      */
3629     public boolean hasPayload() {
3630       return ((bitField0_ & 0x00000010) == 0x00000010);
3631     }
3632     /**
3633      * <code>optional bytes payload = 5;</code>
3634      *
3635      * <pre>
3636      * TODO we are capping this at 8 bytes for now - need to change when we
3637      * support multi-frame responses
3638      * </pre>
3639      */
3640     public com.google.protobuf.ByteString getPayload() {
3641       return payload_;
3642     }
3643
3644     // optional bool multiple_responses = 6;
3645     public static final int MULTIPLE_RESPONSES_FIELD_NUMBER = 6;
3646     private boolean multipleResponses_;
3647     /**
3648      * <code>optional bool multiple_responses = 6;</code>
3649      */
3650     public boolean hasMultipleResponses() {
3651       return ((bitField0_ & 0x00000020) == 0x00000020);
3652     }
3653     /**
3654      * <code>optional bool multiple_responses = 6;</code>
3655      */
3656     public boolean getMultipleResponses() {
3657       return multipleResponses_;
3658     }
3659
3660     // optional double factor = 7;
3661     public static final int FACTOR_FIELD_NUMBER = 7;
3662     private double factor_;
3663     /**
3664      * <code>optional double factor = 7;</code>
3665      */
3666     public boolean hasFactor() {
3667       return ((bitField0_ & 0x00000040) == 0x00000040);
3668     }
3669     /**
3670      * <code>optional double factor = 7;</code>
3671      */
3672     public double getFactor() {
3673       return factor_;
3674     }
3675
3676     // optional double offset = 8;
3677     public static final int OFFSET_FIELD_NUMBER = 8;
3678     private double offset_;
3679     /**
3680      * <code>optional double offset = 8;</code>
3681      */
3682     public boolean hasOffset() {
3683       return ((bitField0_ & 0x00000080) == 0x00000080);
3684     }
3685     /**
3686      * <code>optional double offset = 8;</code>
3687      */
3688     public double getOffset() {
3689       return offset_;
3690     }
3691
3692     // optional double frequency = 9;
3693     public static final int FREQUENCY_FIELD_NUMBER = 9;
3694     private double frequency_;
3695     /**
3696      * <code>optional double frequency = 9;</code>
3697      */
3698     public boolean hasFrequency() {
3699       return ((bitField0_ & 0x00000100) == 0x00000100);
3700     }
3701     /**
3702      * <code>optional double frequency = 9;</code>
3703      */
3704     public double getFrequency() {
3705       return frequency_;
3706     }
3707
3708     // optional string name = 10;
3709     public static final int NAME_FIELD_NUMBER = 10;
3710     private java.lang.Object name_;
3711     /**
3712      * <code>optional string name = 10;</code>
3713      */
3714     public boolean hasName() {
3715       return ((bitField0_ & 0x00000200) == 0x00000200);
3716     }
3717     /**
3718      * <code>optional string name = 10;</code>
3719      */
3720     public java.lang.String getName() {
3721       java.lang.Object ref = name_;
3722       if (ref instanceof java.lang.String) {
3723         return (java.lang.String) ref;
3724       } else {
3725         com.google.protobuf.ByteString bs = 
3726             (com.google.protobuf.ByteString) ref;
3727         java.lang.String s = bs.toStringUtf8();
3728         if (bs.isValidUtf8()) {
3729           name_ = s;
3730         }
3731         return s;
3732       }
3733     }
3734     /**
3735      * <code>optional string name = 10;</code>
3736      */
3737     public com.google.protobuf.ByteString
3738         getNameBytes() {
3739       java.lang.Object ref = name_;
3740       if (ref instanceof java.lang.String) {
3741         com.google.protobuf.ByteString b = 
3742             com.google.protobuf.ByteString.copyFromUtf8(
3743                 (java.lang.String) ref);
3744         name_ = b;
3745         return b;
3746       } else {
3747         return (com.google.protobuf.ByteString) ref;
3748       }
3749     }
3750
3751     private void initFields() {
3752       bus_ = 0;
3753       messageId_ = 0;
3754       mode_ = 0;
3755       pid_ = 0;
3756       payload_ = com.google.protobuf.ByteString.EMPTY;
3757       multipleResponses_ = false;
3758       factor_ = 0D;
3759       offset_ = 0D;
3760       frequency_ = 0D;
3761       name_ = "";
3762     }
3763     private byte memoizedIsInitialized = -1;
3764     public final boolean isInitialized() {
3765       byte isInitialized = memoizedIsInitialized;
3766       if (isInitialized != -1) return isInitialized == 1;
3767
3768       memoizedIsInitialized = 1;
3769       return true;
3770     }
3771
3772     public void writeTo(com.google.protobuf.CodedOutputStream output)
3773                         throws java.io.IOException {
3774       getSerializedSize();
3775       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3776         output.writeInt32(1, bus_);
3777       }
3778       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3779         output.writeUInt32(2, messageId_);
3780       }
3781       if (((bitField0_ & 0x00000004) == 0x00000004)) {
3782         output.writeUInt32(3, mode_);
3783       }
3784       if (((bitField0_ & 0x00000008) == 0x00000008)) {
3785         output.writeUInt32(4, pid_);
3786       }
3787       if (((bitField0_ & 0x00000010) == 0x00000010)) {
3788         output.writeBytes(5, payload_);
3789       }
3790       if (((bitField0_ & 0x00000020) == 0x00000020)) {
3791         output.writeBool(6, multipleResponses_);
3792       }
3793       if (((bitField0_ & 0x00000040) == 0x00000040)) {
3794         output.writeDouble(7, factor_);
3795       }
3796       if (((bitField0_ & 0x00000080) == 0x00000080)) {
3797         output.writeDouble(8, offset_);
3798       }
3799       if (((bitField0_ & 0x00000100) == 0x00000100)) {
3800         output.writeDouble(9, frequency_);
3801       }
3802       if (((bitField0_ & 0x00000200) == 0x00000200)) {
3803         output.writeBytes(10, getNameBytes());
3804       }
3805       getUnknownFields().writeTo(output);
3806     }
3807
3808     private int memoizedSerializedSize = -1;
3809     public int getSerializedSize() {
3810       int size = memoizedSerializedSize;
3811       if (size != -1) return size;
3812
3813       size = 0;
3814       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3815         size += com.google.protobuf.CodedOutputStream
3816           .computeInt32Size(1, bus_);
3817       }
3818       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3819         size += com.google.protobuf.CodedOutputStream
3820           .computeUInt32Size(2, messageId_);
3821       }
3822       if (((bitField0_ & 0x00000004) == 0x00000004)) {
3823         size += com.google.protobuf.CodedOutputStream
3824           .computeUInt32Size(3, mode_);
3825       }
3826       if (((bitField0_ & 0x00000008) == 0x00000008)) {
3827         size += com.google.protobuf.CodedOutputStream
3828           .computeUInt32Size(4, pid_);
3829       }
3830       if (((bitField0_ & 0x00000010) == 0x00000010)) {
3831         size += com.google.protobuf.CodedOutputStream
3832           .computeBytesSize(5, payload_);
3833       }
3834       if (((bitField0_ & 0x00000020) == 0x00000020)) {
3835         size += com.google.protobuf.CodedOutputStream
3836           .computeBoolSize(6, multipleResponses_);
3837       }
3838       if (((bitField0_ & 0x00000040) == 0x00000040)) {
3839         size += com.google.protobuf.CodedOutputStream
3840           .computeDoubleSize(7, factor_);
3841       }
3842       if (((bitField0_ & 0x00000080) == 0x00000080)) {
3843         size += com.google.protobuf.CodedOutputStream
3844           .computeDoubleSize(8, offset_);
3845       }
3846       if (((bitField0_ & 0x00000100) == 0x00000100)) {
3847         size += com.google.protobuf.CodedOutputStream
3848           .computeDoubleSize(9, frequency_);
3849       }
3850       if (((bitField0_ & 0x00000200) == 0x00000200)) {
3851         size += com.google.protobuf.CodedOutputStream
3852           .computeBytesSize(10, getNameBytes());
3853       }
3854       size += getUnknownFields().getSerializedSize();
3855       memoizedSerializedSize = size;
3856       return size;
3857     }
3858
3859     private static final long serialVersionUID = 0L;
3860     @java.lang.Override
3861     protected java.lang.Object writeReplace()
3862         throws java.io.ObjectStreamException {
3863       return super.writeReplace();
3864     }
3865
3866     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
3867         com.google.protobuf.ByteString data)
3868         throws com.google.protobuf.InvalidProtocolBufferException {
3869       return PARSER.parseFrom(data);
3870     }
3871     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
3872         com.google.protobuf.ByteString data,
3873         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3874         throws com.google.protobuf.InvalidProtocolBufferException {
3875       return PARSER.parseFrom(data, extensionRegistry);
3876     }
3877     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(byte[] data)
3878         throws com.google.protobuf.InvalidProtocolBufferException {
3879       return PARSER.parseFrom(data);
3880     }
3881     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
3882         byte[] data,
3883         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3884         throws com.google.protobuf.InvalidProtocolBufferException {
3885       return PARSER.parseFrom(data, extensionRegistry);
3886     }
3887     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(java.io.InputStream input)
3888         throws java.io.IOException {
3889       return PARSER.parseFrom(input);
3890     }
3891     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
3892         java.io.InputStream input,
3893         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3894         throws java.io.IOException {
3895       return PARSER.parseFrom(input, extensionRegistry);
3896     }
3897     public static com.openxc.BinaryMessages.DiagnosticRequest parseDelimitedFrom(java.io.InputStream input)
3898         throws java.io.IOException {
3899       return PARSER.parseDelimitedFrom(input);
3900     }
3901     public static com.openxc.BinaryMessages.DiagnosticRequest parseDelimitedFrom(
3902         java.io.InputStream input,
3903         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3904         throws java.io.IOException {
3905       return PARSER.parseDelimitedFrom(input, extensionRegistry);
3906     }
3907     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
3908         com.google.protobuf.CodedInputStream input)
3909         throws java.io.IOException {
3910       return PARSER.parseFrom(input);
3911     }
3912     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
3913         com.google.protobuf.CodedInputStream input,
3914         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3915         throws java.io.IOException {
3916       return PARSER.parseFrom(input, extensionRegistry);
3917     }
3918
3919     public static Builder newBuilder() { return Builder.create(); }
3920     public Builder newBuilderForType() { return newBuilder(); }
3921     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticRequest prototype) {
3922       return newBuilder().mergeFrom(prototype);
3923     }
3924     public Builder toBuilder() { return newBuilder(this); }
3925
3926     @java.lang.Override
3927     protected Builder newBuilderForType(
3928         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3929       Builder builder = new Builder(parent);
3930       return builder;
3931     }
3932     /**
3933      * Protobuf type {@code openxc.DiagnosticRequest}
3934      */
3935     public static final class Builder extends
3936         com.google.protobuf.GeneratedMessage.Builder<Builder>
3937        implements com.openxc.BinaryMessages.DiagnosticRequestOrBuilder {
3938       public static final com.google.protobuf.Descriptors.Descriptor
3939           getDescriptor() {
3940         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
3941       }
3942
3943       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3944           internalGetFieldAccessorTable() {
3945         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_fieldAccessorTable
3946             .ensureFieldAccessorsInitialized(
3947                 com.openxc.BinaryMessages.DiagnosticRequest.class, com.openxc.BinaryMessages.DiagnosticRequest.Builder.class);
3948       }
3949
3950       // Construct using com.openxc.BinaryMessages.DiagnosticRequest.newBuilder()
3951       private Builder() {
3952         maybeForceBuilderInitialization();
3953       }
3954
3955       private Builder(
3956           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3957         super(parent);
3958         maybeForceBuilderInitialization();
3959       }
3960       private void maybeForceBuilderInitialization() {
3961         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
3962         }
3963       }
3964       private static Builder create() {
3965         return new Builder();
3966       }
3967
3968       public Builder clear() {
3969         super.clear();
3970         bus_ = 0;
3971         bitField0_ = (bitField0_ & ~0x00000001);
3972         messageId_ = 0;
3973         bitField0_ = (bitField0_ & ~0x00000002);
3974         mode_ = 0;
3975         bitField0_ = (bitField0_ & ~0x00000004);
3976         pid_ = 0;
3977         bitField0_ = (bitField0_ & ~0x00000008);
3978         payload_ = com.google.protobuf.ByteString.EMPTY;
3979         bitField0_ = (bitField0_ & ~0x00000010);
3980         multipleResponses_ = false;
3981         bitField0_ = (bitField0_ & ~0x00000020);
3982         factor_ = 0D;
3983         bitField0_ = (bitField0_ & ~0x00000040);
3984         offset_ = 0D;
3985         bitField0_ = (bitField0_ & ~0x00000080);
3986         frequency_ = 0D;
3987         bitField0_ = (bitField0_ & ~0x00000100);
3988         name_ = "";
3989         bitField0_ = (bitField0_ & ~0x00000200);
3990         return this;
3991       }
3992
3993       public Builder clone() {
3994         return create().mergeFrom(buildPartial());
3995       }
3996
3997       public com.google.protobuf.Descriptors.Descriptor
3998           getDescriptorForType() {
3999         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
4000       }
4001
4002       public com.openxc.BinaryMessages.DiagnosticRequest getDefaultInstanceForType() {
4003         return com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
4004       }
4005
4006       public com.openxc.BinaryMessages.DiagnosticRequest build() {
4007         com.openxc.BinaryMessages.DiagnosticRequest result = buildPartial();
4008         if (!result.isInitialized()) {
4009           throw newUninitializedMessageException(result);
4010         }
4011         return result;
4012       }
4013
4014       public com.openxc.BinaryMessages.DiagnosticRequest buildPartial() {
4015         com.openxc.BinaryMessages.DiagnosticRequest result = new com.openxc.BinaryMessages.DiagnosticRequest(this);
4016         int from_bitField0_ = bitField0_;
4017         int to_bitField0_ = 0;
4018         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
4019           to_bitField0_ |= 0x00000001;
4020         }
4021         result.bus_ = bus_;
4022         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
4023           to_bitField0_ |= 0x00000002;
4024         }
4025         result.messageId_ = messageId_;
4026         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
4027           to_bitField0_ |= 0x00000004;
4028         }
4029         result.mode_ = mode_;
4030         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
4031           to_bitField0_ |= 0x00000008;
4032         }
4033         result.pid_ = pid_;
4034         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
4035           to_bitField0_ |= 0x00000010;
4036         }
4037         result.payload_ = payload_;
4038         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
4039           to_bitField0_ |= 0x00000020;
4040         }
4041         result.multipleResponses_ = multipleResponses_;
4042         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
4043           to_bitField0_ |= 0x00000040;
4044         }
4045         result.factor_ = factor_;
4046         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
4047           to_bitField0_ |= 0x00000080;
4048         }
4049         result.offset_ = offset_;
4050         if (((from_bitField0_ & 0x00000100) == 0x00000100)) {
4051           to_bitField0_ |= 0x00000100;
4052         }
4053         result.frequency_ = frequency_;
4054         if (((from_bitField0_ & 0x00000200) == 0x00000200)) {
4055           to_bitField0_ |= 0x00000200;
4056         }
4057         result.name_ = name_;
4058         result.bitField0_ = to_bitField0_;
4059         onBuilt();
4060         return result;
4061       }
4062
4063       public Builder mergeFrom(com.google.protobuf.Message other) {
4064         if (other instanceof com.openxc.BinaryMessages.DiagnosticRequest) {
4065           return mergeFrom((com.openxc.BinaryMessages.DiagnosticRequest)other);
4066         } else {
4067           super.mergeFrom(other);
4068           return this;
4069         }
4070       }
4071
4072       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticRequest other) {
4073         if (other == com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance()) return this;
4074         if (other.hasBus()) {
4075           setBus(other.getBus());
4076         }
4077         if (other.hasMessageId()) {
4078           setMessageId(other.getMessageId());
4079         }
4080         if (other.hasMode()) {
4081           setMode(other.getMode());
4082         }
4083         if (other.hasPid()) {
4084           setPid(other.getPid());
4085         }
4086         if (other.hasPayload()) {
4087           setPayload(other.getPayload());
4088         }
4089         if (other.hasMultipleResponses()) {
4090           setMultipleResponses(other.getMultipleResponses());
4091         }
4092         if (other.hasFactor()) {
4093           setFactor(other.getFactor());
4094         }
4095         if (other.hasOffset()) {
4096           setOffset(other.getOffset());
4097         }
4098         if (other.hasFrequency()) {
4099           setFrequency(other.getFrequency());
4100         }
4101         if (other.hasName()) {
4102           bitField0_ |= 0x00000200;
4103           name_ = other.name_;
4104           onChanged();
4105         }
4106         this.mergeUnknownFields(other.getUnknownFields());
4107         return this;
4108       }
4109
4110       public final boolean isInitialized() {
4111         return true;
4112       }
4113
4114       public Builder mergeFrom(
4115           com.google.protobuf.CodedInputStream input,
4116           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4117           throws java.io.IOException {
4118         com.openxc.BinaryMessages.DiagnosticRequest parsedMessage = null;
4119         try {
4120           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
4121         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4122           parsedMessage = (com.openxc.BinaryMessages.DiagnosticRequest) e.getUnfinishedMessage();
4123           throw e;
4124         } finally {
4125           if (parsedMessage != null) {
4126             mergeFrom(parsedMessage);
4127           }
4128         }
4129         return this;
4130       }
4131       private int bitField0_;
4132
4133       // optional int32 bus = 1;
4134       private int bus_ ;
4135       /**
4136        * <code>optional int32 bus = 1;</code>
4137        */
4138       public boolean hasBus() {
4139         return ((bitField0_ & 0x00000001) == 0x00000001);
4140       }
4141       /**
4142        * <code>optional int32 bus = 1;</code>
4143        */
4144       public int getBus() {
4145         return bus_;
4146       }
4147       /**
4148        * <code>optional int32 bus = 1;</code>
4149        */
4150       public Builder setBus(int value) {
4151         bitField0_ |= 0x00000001;
4152         bus_ = value;
4153         onChanged();
4154         return this;
4155       }
4156       /**
4157        * <code>optional int32 bus = 1;</code>
4158        */
4159       public Builder clearBus() {
4160         bitField0_ = (bitField0_ & ~0x00000001);
4161         bus_ = 0;
4162         onChanged();
4163         return this;
4164       }
4165
4166       // optional uint32 message_id = 2;
4167       private int messageId_ ;
4168       /**
4169        * <code>optional uint32 message_id = 2;</code>
4170        */
4171       public boolean hasMessageId() {
4172         return ((bitField0_ & 0x00000002) == 0x00000002);
4173       }
4174       /**
4175        * <code>optional uint32 message_id = 2;</code>
4176        */
4177       public int getMessageId() {
4178         return messageId_;
4179       }
4180       /**
4181        * <code>optional uint32 message_id = 2;</code>
4182        */
4183       public Builder setMessageId(int value) {
4184         bitField0_ |= 0x00000002;
4185         messageId_ = value;
4186         onChanged();
4187         return this;
4188       }
4189       /**
4190        * <code>optional uint32 message_id = 2;</code>
4191        */
4192       public Builder clearMessageId() {
4193         bitField0_ = (bitField0_ & ~0x00000002);
4194         messageId_ = 0;
4195         onChanged();
4196         return this;
4197       }
4198
4199       // optional uint32 mode = 3;
4200       private int mode_ ;
4201       /**
4202        * <code>optional uint32 mode = 3;</code>
4203        */
4204       public boolean hasMode() {
4205         return ((bitField0_ & 0x00000004) == 0x00000004);
4206       }
4207       /**
4208        * <code>optional uint32 mode = 3;</code>
4209        */
4210       public int getMode() {
4211         return mode_;
4212       }
4213       /**
4214        * <code>optional uint32 mode = 3;</code>
4215        */
4216       public Builder setMode(int value) {
4217         bitField0_ |= 0x00000004;
4218         mode_ = value;
4219         onChanged();
4220         return this;
4221       }
4222       /**
4223        * <code>optional uint32 mode = 3;</code>
4224        */
4225       public Builder clearMode() {
4226         bitField0_ = (bitField0_ & ~0x00000004);
4227         mode_ = 0;
4228         onChanged();
4229         return this;
4230       }
4231
4232       // optional uint32 pid = 4;
4233       private int pid_ ;
4234       /**
4235        * <code>optional uint32 pid = 4;</code>
4236        */
4237       public boolean hasPid() {
4238         return ((bitField0_ & 0x00000008) == 0x00000008);
4239       }
4240       /**
4241        * <code>optional uint32 pid = 4;</code>
4242        */
4243       public int getPid() {
4244         return pid_;
4245       }
4246       /**
4247        * <code>optional uint32 pid = 4;</code>
4248        */
4249       public Builder setPid(int value) {
4250         bitField0_ |= 0x00000008;
4251         pid_ = value;
4252         onChanged();
4253         return this;
4254       }
4255       /**
4256        * <code>optional uint32 pid = 4;</code>
4257        */
4258       public Builder clearPid() {
4259         bitField0_ = (bitField0_ & ~0x00000008);
4260         pid_ = 0;
4261         onChanged();
4262         return this;
4263       }
4264
4265       // optional bytes payload = 5;
4266       private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY;
4267       /**
4268        * <code>optional bytes payload = 5;</code>
4269        *
4270        * <pre>
4271        * TODO we are capping this at 8 bytes for now - need to change when we
4272        * support multi-frame responses
4273        * </pre>
4274        */
4275       public boolean hasPayload() {
4276         return ((bitField0_ & 0x00000010) == 0x00000010);
4277       }
4278       /**
4279        * <code>optional bytes payload = 5;</code>
4280        *
4281        * <pre>
4282        * TODO we are capping this at 8 bytes for now - need to change when we
4283        * support multi-frame responses
4284        * </pre>
4285        */
4286       public com.google.protobuf.ByteString getPayload() {
4287         return payload_;
4288       }
4289       /**
4290        * <code>optional bytes payload = 5;</code>
4291        *
4292        * <pre>
4293        * TODO we are capping this at 8 bytes for now - need to change when we
4294        * support multi-frame responses
4295        * </pre>
4296        */
4297       public Builder setPayload(com.google.protobuf.ByteString value) {
4298         if (value == null) {
4299     throw new NullPointerException();
4300   }
4301   bitField0_ |= 0x00000010;
4302         payload_ = value;
4303         onChanged();
4304         return this;
4305       }
4306       /**
4307        * <code>optional bytes payload = 5;</code>
4308        *
4309        * <pre>
4310        * TODO we are capping this at 8 bytes for now - need to change when we
4311        * support multi-frame responses
4312        * </pre>
4313        */
4314       public Builder clearPayload() {
4315         bitField0_ = (bitField0_ & ~0x00000010);
4316         payload_ = getDefaultInstance().getPayload();
4317         onChanged();
4318         return this;
4319       }
4320
4321       // optional bool multiple_responses = 6;
4322       private boolean multipleResponses_ ;
4323       /**
4324        * <code>optional bool multiple_responses = 6;</code>
4325        */
4326       public boolean hasMultipleResponses() {
4327         return ((bitField0_ & 0x00000020) == 0x00000020);
4328       }
4329       /**
4330        * <code>optional bool multiple_responses = 6;</code>
4331        */
4332       public boolean getMultipleResponses() {
4333         return multipleResponses_;
4334       }
4335       /**
4336        * <code>optional bool multiple_responses = 6;</code>
4337        */
4338       public Builder setMultipleResponses(boolean value) {
4339         bitField0_ |= 0x00000020;
4340         multipleResponses_ = value;
4341         onChanged();
4342         return this;
4343       }
4344       /**
4345        * <code>optional bool multiple_responses = 6;</code>
4346        */
4347       public Builder clearMultipleResponses() {
4348         bitField0_ = (bitField0_ & ~0x00000020);
4349         multipleResponses_ = false;
4350         onChanged();
4351         return this;
4352       }
4353
4354       // optional double factor = 7;
4355       private double factor_ ;
4356       /**
4357        * <code>optional double factor = 7;</code>
4358        */
4359       public boolean hasFactor() {
4360         return ((bitField0_ & 0x00000040) == 0x00000040);
4361       }
4362       /**
4363        * <code>optional double factor = 7;</code>
4364        */
4365       public double getFactor() {
4366         return factor_;
4367       }
4368       /**
4369        * <code>optional double factor = 7;</code>
4370        */
4371       public Builder setFactor(double value) {
4372         bitField0_ |= 0x00000040;
4373         factor_ = value;
4374         onChanged();
4375         return this;
4376       }
4377       /**
4378        * <code>optional double factor = 7;</code>
4379        */
4380       public Builder clearFactor() {
4381         bitField0_ = (bitField0_ & ~0x00000040);
4382         factor_ = 0D;
4383         onChanged();
4384         return this;
4385       }
4386
4387       // optional double offset = 8;
4388       private double offset_ ;
4389       /**
4390        * <code>optional double offset = 8;</code>
4391        */
4392       public boolean hasOffset() {
4393         return ((bitField0_ & 0x00000080) == 0x00000080);
4394       }
4395       /**
4396        * <code>optional double offset = 8;</code>
4397        */
4398       public double getOffset() {
4399         return offset_;
4400       }
4401       /**
4402        * <code>optional double offset = 8;</code>
4403        */
4404       public Builder setOffset(double value) {
4405         bitField0_ |= 0x00000080;
4406         offset_ = value;
4407         onChanged();
4408         return this;
4409       }
4410       /**
4411        * <code>optional double offset = 8;</code>
4412        */
4413       public Builder clearOffset() {
4414         bitField0_ = (bitField0_ & ~0x00000080);
4415         offset_ = 0D;
4416         onChanged();
4417         return this;
4418       }
4419
4420       // optional double frequency = 9;
4421       private double frequency_ ;
4422       /**
4423        * <code>optional double frequency = 9;</code>
4424        */
4425       public boolean hasFrequency() {
4426         return ((bitField0_ & 0x00000100) == 0x00000100);
4427       }
4428       /**
4429        * <code>optional double frequency = 9;</code>
4430        */
4431       public double getFrequency() {
4432         return frequency_;
4433       }
4434       /**
4435        * <code>optional double frequency = 9;</code>
4436        */
4437       public Builder setFrequency(double value) {
4438         bitField0_ |= 0x00000100;
4439         frequency_ = value;
4440         onChanged();
4441         return this;
4442       }
4443       /**
4444        * <code>optional double frequency = 9;</code>
4445        */
4446       public Builder clearFrequency() {
4447         bitField0_ = (bitField0_ & ~0x00000100);
4448         frequency_ = 0D;
4449         onChanged();
4450         return this;
4451       }
4452
4453       // optional string name = 10;
4454       private java.lang.Object name_ = "";
4455       /**
4456        * <code>optional string name = 10;</code>
4457        */
4458       public boolean hasName() {
4459         return ((bitField0_ & 0x00000200) == 0x00000200);
4460       }
4461       /**
4462        * <code>optional string name = 10;</code>
4463        */
4464       public java.lang.String getName() {
4465         java.lang.Object ref = name_;
4466         if (!(ref instanceof java.lang.String)) {
4467           java.lang.String s = ((com.google.protobuf.ByteString) ref)
4468               .toStringUtf8();
4469           name_ = s;
4470           return s;
4471         } else {
4472           return (java.lang.String) ref;
4473         }
4474       }
4475       /**
4476        * <code>optional string name = 10;</code>
4477        */
4478       public com.google.protobuf.ByteString
4479           getNameBytes() {
4480         java.lang.Object ref = name_;
4481         if (ref instanceof String) {
4482           com.google.protobuf.ByteString b = 
4483               com.google.protobuf.ByteString.copyFromUtf8(
4484                   (java.lang.String) ref);
4485           name_ = b;
4486           return b;
4487         } else {
4488           return (com.google.protobuf.ByteString) ref;
4489         }
4490       }
4491       /**
4492        * <code>optional string name = 10;</code>
4493        */
4494       public Builder setName(
4495           java.lang.String value) {
4496         if (value == null) {
4497     throw new NullPointerException();
4498   }
4499   bitField0_ |= 0x00000200;
4500         name_ = value;
4501         onChanged();
4502         return this;
4503       }
4504       /**
4505        * <code>optional string name = 10;</code>
4506        */
4507       public Builder clearName() {
4508         bitField0_ = (bitField0_ & ~0x00000200);
4509         name_ = getDefaultInstance().getName();
4510         onChanged();
4511         return this;
4512       }
4513       /**
4514        * <code>optional string name = 10;</code>
4515        */
4516       public Builder setNameBytes(
4517           com.google.protobuf.ByteString value) {
4518         if (value == null) {
4519     throw new NullPointerException();
4520   }
4521   bitField0_ |= 0x00000200;
4522         name_ = value;
4523         onChanged();
4524         return this;
4525       }
4526
4527       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticRequest)
4528     }
4529
4530     static {
4531       defaultInstance = new DiagnosticRequest(true);
4532       defaultInstance.initFields();
4533     }
4534
4535     // @@protoc_insertion_point(class_scope:openxc.DiagnosticRequest)
4536   }
4537
4538   public interface DiagnosticResponseOrBuilder
4539       extends com.google.protobuf.MessageOrBuilder {
4540
4541     // optional int32 bus = 1;
4542     /**
4543      * <code>optional int32 bus = 1;</code>
4544      */
4545     boolean hasBus();
4546     /**
4547      * <code>optional int32 bus = 1;</code>
4548      */
4549     int getBus();
4550
4551     // optional uint32 message_id = 2;
4552     /**
4553      * <code>optional uint32 message_id = 2;</code>
4554      */
4555     boolean hasMessageId();
4556     /**
4557      * <code>optional uint32 message_id = 2;</code>
4558      */
4559     int getMessageId();
4560
4561     // optional uint32 mode = 3;
4562     /**
4563      * <code>optional uint32 mode = 3;</code>
4564      */
4565     boolean hasMode();
4566     /**
4567      * <code>optional uint32 mode = 3;</code>
4568      */
4569     int getMode();
4570
4571     // optional uint32 pid = 4;
4572     /**
4573      * <code>optional uint32 pid = 4;</code>
4574      */
4575     boolean hasPid();
4576     /**
4577      * <code>optional uint32 pid = 4;</code>
4578      */
4579     int getPid();
4580
4581     // optional bool success = 5;
4582     /**
4583      * <code>optional bool success = 5;</code>
4584      */
4585     boolean hasSuccess();
4586     /**
4587      * <code>optional bool success = 5;</code>
4588      */
4589     boolean getSuccess();
4590
4591     // optional uint32 negative_response_code = 6;
4592     /**
4593      * <code>optional uint32 negative_response_code = 6;</code>
4594      */
4595     boolean hasNegativeResponseCode();
4596     /**
4597      * <code>optional uint32 negative_response_code = 6;</code>
4598      */
4599     int getNegativeResponseCode();
4600
4601     // optional bytes payload = 7;
4602     /**
4603      * <code>optional bytes payload = 7;</code>
4604      *
4605      * <pre>
4606      * TODO we are capping this at 8 bytes for now - need to change when we
4607      * support multi-frame responses
4608      * </pre>
4609      */
4610     boolean hasPayload();
4611     /**
4612      * <code>optional bytes payload = 7;</code>
4613      *
4614      * <pre>
4615      * TODO we are capping this at 8 bytes for now - need to change when we
4616      * support multi-frame responses
4617      * </pre>
4618      */
4619     com.google.protobuf.ByteString getPayload();
4620
4621     // optional double value = 8;
4622     /**
4623      * <code>optional double value = 8;</code>
4624      */
4625     boolean hasValue();
4626     /**
4627      * <code>optional double value = 8;</code>
4628      */
4629     double getValue();
4630   }
4631   /**
4632    * Protobuf type {@code openxc.DiagnosticResponse}
4633    */
4634   public static final class DiagnosticResponse extends
4635       com.google.protobuf.GeneratedMessage
4636       implements DiagnosticResponseOrBuilder {
4637     // Use DiagnosticResponse.newBuilder() to construct.
4638     private DiagnosticResponse(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
4639       super(builder);
4640       this.unknownFields = builder.getUnknownFields();
4641     }
4642     private DiagnosticResponse(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
4643
4644     private static final DiagnosticResponse defaultInstance;
4645     public static DiagnosticResponse getDefaultInstance() {
4646       return defaultInstance;
4647     }
4648
4649     public DiagnosticResponse getDefaultInstanceForType() {
4650       return defaultInstance;
4651     }
4652
4653     private final com.google.protobuf.UnknownFieldSet unknownFields;
4654     @java.lang.Override
4655     public final com.google.protobuf.UnknownFieldSet
4656         getUnknownFields() {
4657       return this.unknownFields;
4658     }
4659     private DiagnosticResponse(
4660         com.google.protobuf.CodedInputStream input,
4661         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4662         throws com.google.protobuf.InvalidProtocolBufferException {
4663       initFields();
4664       int mutable_bitField0_ = 0;
4665       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
4666           com.google.protobuf.UnknownFieldSet.newBuilder();
4667       try {
4668         boolean done = false;
4669         while (!done) {
4670           int tag = input.readTag();
4671           switch (tag) {
4672             case 0:
4673               done = true;
4674               break;
4675             default: {
4676               if (!parseUnknownField(input, unknownFields,
4677                                      extensionRegistry, tag)) {
4678                 done = true;
4679               }
4680               break;
4681             }
4682             case 8: {
4683               bitField0_ |= 0x00000001;
4684               bus_ = input.readInt32();
4685               break;
4686             }
4687             case 16: {
4688               bitField0_ |= 0x00000002;
4689               messageId_ = input.readUInt32();
4690               break;
4691             }
4692             case 24: {
4693               bitField0_ |= 0x00000004;
4694               mode_ = input.readUInt32();
4695               break;
4696             }
4697             case 32: {
4698               bitField0_ |= 0x00000008;
4699               pid_ = input.readUInt32();
4700               break;
4701             }
4702             case 40: {
4703               bitField0_ |= 0x00000010;
4704               success_ = input.readBool();
4705               break;
4706             }
4707             case 48: {
4708               bitField0_ |= 0x00000020;
4709               negativeResponseCode_ = input.readUInt32();
4710               break;
4711             }
4712             case 58: {
4713               bitField0_ |= 0x00000040;
4714               payload_ = input.readBytes();
4715               break;
4716             }
4717             case 65: {
4718               bitField0_ |= 0x00000080;
4719               value_ = input.readDouble();
4720               break;
4721             }
4722           }
4723         }
4724       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4725         throw e.setUnfinishedMessage(this);
4726       } catch (java.io.IOException e) {
4727         throw new com.google.protobuf.InvalidProtocolBufferException(
4728             e.getMessage()).setUnfinishedMessage(this);
4729       } finally {
4730         this.unknownFields = unknownFields.build();
4731         makeExtensionsImmutable();
4732       }
4733     }
4734     public static final com.google.protobuf.Descriptors.Descriptor
4735         getDescriptor() {
4736       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
4737     }
4738
4739     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4740         internalGetFieldAccessorTable() {
4741       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_fieldAccessorTable
4742           .ensureFieldAccessorsInitialized(
4743               com.openxc.BinaryMessages.DiagnosticResponse.class, com.openxc.BinaryMessages.DiagnosticResponse.Builder.class);
4744     }
4745
4746     public static com.google.protobuf.Parser<DiagnosticResponse> PARSER =
4747         new com.google.protobuf.AbstractParser<DiagnosticResponse>() {
4748       public DiagnosticResponse parsePartialFrom(
4749           com.google.protobuf.CodedInputStream input,
4750           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4751           throws com.google.protobuf.InvalidProtocolBufferException {
4752         return new DiagnosticResponse(input, extensionRegistry);
4753       }
4754     };
4755
4756     @java.lang.Override
4757     public com.google.protobuf.Parser<DiagnosticResponse> getParserForType() {
4758       return PARSER;
4759     }
4760
4761     private int bitField0_;
4762     // optional int32 bus = 1;
4763     public static final int BUS_FIELD_NUMBER = 1;
4764     private int bus_;
4765     /**
4766      * <code>optional int32 bus = 1;</code>
4767      */
4768     public boolean hasBus() {
4769       return ((bitField0_ & 0x00000001) == 0x00000001);
4770     }
4771     /**
4772      * <code>optional int32 bus = 1;</code>
4773      */
4774     public int getBus() {
4775       return bus_;
4776     }
4777
4778     // optional uint32 message_id = 2;
4779     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
4780     private int messageId_;
4781     /**
4782      * <code>optional uint32 message_id = 2;</code>
4783      */
4784     public boolean hasMessageId() {
4785       return ((bitField0_ & 0x00000002) == 0x00000002);
4786     }
4787     /**
4788      * <code>optional uint32 message_id = 2;</code>
4789      */
4790     public int getMessageId() {
4791       return messageId_;
4792     }
4793
4794     // optional uint32 mode = 3;
4795     public static final int MODE_FIELD_NUMBER = 3;
4796     private int mode_;
4797     /**
4798      * <code>optional uint32 mode = 3;</code>
4799      */
4800     public boolean hasMode() {
4801       return ((bitField0_ & 0x00000004) == 0x00000004);
4802     }
4803     /**
4804      * <code>optional uint32 mode = 3;</code>
4805      */
4806     public int getMode() {
4807       return mode_;
4808     }
4809
4810     // optional uint32 pid = 4;
4811     public static final int PID_FIELD_NUMBER = 4;
4812     private int pid_;
4813     /**
4814      * <code>optional uint32 pid = 4;</code>
4815      */
4816     public boolean hasPid() {
4817       return ((bitField0_ & 0x00000008) == 0x00000008);
4818     }
4819     /**
4820      * <code>optional uint32 pid = 4;</code>
4821      */
4822     public int getPid() {
4823       return pid_;
4824     }
4825
4826     // optional bool success = 5;
4827     public static final int SUCCESS_FIELD_NUMBER = 5;
4828     private boolean success_;
4829     /**
4830      * <code>optional bool success = 5;</code>
4831      */
4832     public boolean hasSuccess() {
4833       return ((bitField0_ & 0x00000010) == 0x00000010);
4834     }
4835     /**
4836      * <code>optional bool success = 5;</code>
4837      */
4838     public boolean getSuccess() {
4839       return success_;
4840     }
4841
4842     // optional uint32 negative_response_code = 6;
4843     public static final int NEGATIVE_RESPONSE_CODE_FIELD_NUMBER = 6;
4844     private int negativeResponseCode_;
4845     /**
4846      * <code>optional uint32 negative_response_code = 6;</code>
4847      */
4848     public boolean hasNegativeResponseCode() {
4849       return ((bitField0_ & 0x00000020) == 0x00000020);
4850     }
4851     /**
4852      * <code>optional uint32 negative_response_code = 6;</code>
4853      */
4854     public int getNegativeResponseCode() {
4855       return negativeResponseCode_;
4856     }
4857
4858     // optional bytes payload = 7;
4859     public static final int PAYLOAD_FIELD_NUMBER = 7;
4860     private com.google.protobuf.ByteString payload_;
4861     /**
4862      * <code>optional bytes payload = 7;</code>
4863      *
4864      * <pre>
4865      * TODO we are capping this at 8 bytes for now - need to change when we
4866      * support multi-frame responses
4867      * </pre>
4868      */
4869     public boolean hasPayload() {
4870       return ((bitField0_ & 0x00000040) == 0x00000040);
4871     }
4872     /**
4873      * <code>optional bytes payload = 7;</code>
4874      *
4875      * <pre>
4876      * TODO we are capping this at 8 bytes for now - need to change when we
4877      * support multi-frame responses
4878      * </pre>
4879      */
4880     public com.google.protobuf.ByteString getPayload() {
4881       return payload_;
4882     }
4883
4884     // optional double value = 8;
4885     public static final int VALUE_FIELD_NUMBER = 8;
4886     private double value_;
4887     /**
4888      * <code>optional double value = 8;</code>
4889      */
4890     public boolean hasValue() {
4891       return ((bitField0_ & 0x00000080) == 0x00000080);
4892     }
4893     /**
4894      * <code>optional double value = 8;</code>
4895      */
4896     public double getValue() {
4897       return value_;
4898     }
4899
4900     private void initFields() {
4901       bus_ = 0;
4902       messageId_ = 0;
4903       mode_ = 0;
4904       pid_ = 0;
4905       success_ = false;
4906       negativeResponseCode_ = 0;
4907       payload_ = com.google.protobuf.ByteString.EMPTY;
4908       value_ = 0D;
4909     }
4910     private byte memoizedIsInitialized = -1;
4911     public final boolean isInitialized() {
4912       byte isInitialized = memoizedIsInitialized;
4913       if (isInitialized != -1) return isInitialized == 1;
4914
4915       memoizedIsInitialized = 1;
4916       return true;
4917     }
4918
4919     public void writeTo(com.google.protobuf.CodedOutputStream output)
4920                         throws java.io.IOException {
4921       getSerializedSize();
4922       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4923         output.writeInt32(1, bus_);
4924       }
4925       if (((bitField0_ & 0x00000002) == 0x00000002)) {
4926         output.writeUInt32(2, messageId_);
4927       }
4928       if (((bitField0_ & 0x00000004) == 0x00000004)) {
4929         output.writeUInt32(3, mode_);
4930       }
4931       if (((bitField0_ & 0x00000008) == 0x00000008)) {
4932         output.writeUInt32(4, pid_);
4933       }
4934       if (((bitField0_ & 0x00000010) == 0x00000010)) {
4935         output.writeBool(5, success_);
4936       }
4937       if (((bitField0_ & 0x00000020) == 0x00000020)) {
4938         output.writeUInt32(6, negativeResponseCode_);
4939       }
4940       if (((bitField0_ & 0x00000040) == 0x00000040)) {
4941         output.writeBytes(7, payload_);
4942       }
4943       if (((bitField0_ & 0x00000080) == 0x00000080)) {
4944         output.writeDouble(8, value_);
4945       }
4946       getUnknownFields().writeTo(output);
4947     }
4948
4949     private int memoizedSerializedSize = -1;
4950     public int getSerializedSize() {
4951       int size = memoizedSerializedSize;
4952       if (size != -1) return size;
4953
4954       size = 0;
4955       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4956         size += com.google.protobuf.CodedOutputStream
4957           .computeInt32Size(1, bus_);
4958       }
4959       if (((bitField0_ & 0x00000002) == 0x00000002)) {
4960         size += com.google.protobuf.CodedOutputStream
4961           .computeUInt32Size(2, messageId_);
4962       }
4963       if (((bitField0_ & 0x00000004) == 0x00000004)) {
4964         size += com.google.protobuf.CodedOutputStream
4965           .computeUInt32Size(3, mode_);
4966       }
4967       if (((bitField0_ & 0x00000008) == 0x00000008)) {
4968         size += com.google.protobuf.CodedOutputStream
4969           .computeUInt32Size(4, pid_);
4970       }
4971       if (((bitField0_ & 0x00000010) == 0x00000010)) {
4972         size += com.google.protobuf.CodedOutputStream
4973           .computeBoolSize(5, success_);
4974       }
4975       if (((bitField0_ & 0x00000020) == 0x00000020)) {
4976         size += com.google.protobuf.CodedOutputStream
4977           .computeUInt32Size(6, negativeResponseCode_);
4978       }
4979       if (((bitField0_ & 0x00000040) == 0x00000040)) {
4980         size += com.google.protobuf.CodedOutputStream
4981           .computeBytesSize(7, payload_);
4982       }
4983       if (((bitField0_ & 0x00000080) == 0x00000080)) {
4984         size += com.google.protobuf.CodedOutputStream
4985           .computeDoubleSize(8, value_);
4986       }
4987       size += getUnknownFields().getSerializedSize();
4988       memoizedSerializedSize = size;
4989       return size;
4990     }
4991
4992     private static final long serialVersionUID = 0L;
4993     @java.lang.Override
4994     protected java.lang.Object writeReplace()
4995         throws java.io.ObjectStreamException {
4996       return super.writeReplace();
4997     }
4998
4999     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5000         com.google.protobuf.ByteString data)
5001         throws com.google.protobuf.InvalidProtocolBufferException {
5002       return PARSER.parseFrom(data);
5003     }
5004     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5005         com.google.protobuf.ByteString data,
5006         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5007         throws com.google.protobuf.InvalidProtocolBufferException {
5008       return PARSER.parseFrom(data, extensionRegistry);
5009     }
5010     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(byte[] data)
5011         throws com.google.protobuf.InvalidProtocolBufferException {
5012       return PARSER.parseFrom(data);
5013     }
5014     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5015         byte[] data,
5016         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5017         throws com.google.protobuf.InvalidProtocolBufferException {
5018       return PARSER.parseFrom(data, extensionRegistry);
5019     }
5020     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(java.io.InputStream input)
5021         throws java.io.IOException {
5022       return PARSER.parseFrom(input);
5023     }
5024     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5025         java.io.InputStream input,
5026         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5027         throws java.io.IOException {
5028       return PARSER.parseFrom(input, extensionRegistry);
5029     }
5030     public static com.openxc.BinaryMessages.DiagnosticResponse parseDelimitedFrom(java.io.InputStream input)
5031         throws java.io.IOException {
5032       return PARSER.parseDelimitedFrom(input);
5033     }
5034     public static com.openxc.BinaryMessages.DiagnosticResponse parseDelimitedFrom(
5035         java.io.InputStream input,
5036         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5037         throws java.io.IOException {
5038       return PARSER.parseDelimitedFrom(input, extensionRegistry);
5039     }
5040     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5041         com.google.protobuf.CodedInputStream input)
5042         throws java.io.IOException {
5043       return PARSER.parseFrom(input);
5044     }
5045     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5046         com.google.protobuf.CodedInputStream input,
5047         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5048         throws java.io.IOException {
5049       return PARSER.parseFrom(input, extensionRegistry);
5050     }
5051
5052     public static Builder newBuilder() { return Builder.create(); }
5053     public Builder newBuilderForType() { return newBuilder(); }
5054     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticResponse prototype) {
5055       return newBuilder().mergeFrom(prototype);
5056     }
5057     public Builder toBuilder() { return newBuilder(this); }
5058
5059     @java.lang.Override
5060     protected Builder newBuilderForType(
5061         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5062       Builder builder = new Builder(parent);
5063       return builder;
5064     }
5065     /**
5066      * Protobuf type {@code openxc.DiagnosticResponse}
5067      */
5068     public static final class Builder extends
5069         com.google.protobuf.GeneratedMessage.Builder<Builder>
5070        implements com.openxc.BinaryMessages.DiagnosticResponseOrBuilder {
5071       public static final com.google.protobuf.Descriptors.Descriptor
5072           getDescriptor() {
5073         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
5074       }
5075
5076       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5077           internalGetFieldAccessorTable() {
5078         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_fieldAccessorTable
5079             .ensureFieldAccessorsInitialized(
5080                 com.openxc.BinaryMessages.DiagnosticResponse.class, com.openxc.BinaryMessages.DiagnosticResponse.Builder.class);
5081       }
5082
5083       // Construct using com.openxc.BinaryMessages.DiagnosticResponse.newBuilder()
5084       private Builder() {
5085         maybeForceBuilderInitialization();
5086       }
5087
5088       private Builder(
5089           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5090         super(parent);
5091         maybeForceBuilderInitialization();
5092       }
5093       private void maybeForceBuilderInitialization() {
5094         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
5095         }
5096       }
5097       private static Builder create() {
5098         return new Builder();
5099       }
5100
5101       public Builder clear() {
5102         super.clear();
5103         bus_ = 0;
5104         bitField0_ = (bitField0_ & ~0x00000001);
5105         messageId_ = 0;
5106         bitField0_ = (bitField0_ & ~0x00000002);
5107         mode_ = 0;
5108         bitField0_ = (bitField0_ & ~0x00000004);
5109         pid_ = 0;
5110         bitField0_ = (bitField0_ & ~0x00000008);
5111         success_ = false;
5112         bitField0_ = (bitField0_ & ~0x00000010);
5113         negativeResponseCode_ = 0;
5114         bitField0_ = (bitField0_ & ~0x00000020);
5115         payload_ = com.google.protobuf.ByteString.EMPTY;
5116         bitField0_ = (bitField0_ & ~0x00000040);
5117         value_ = 0D;
5118         bitField0_ = (bitField0_ & ~0x00000080);
5119         return this;
5120       }
5121
5122       public Builder clone() {
5123         return create().mergeFrom(buildPartial());
5124       }
5125
5126       public com.google.protobuf.Descriptors.Descriptor
5127           getDescriptorForType() {
5128         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
5129       }
5130
5131       public com.openxc.BinaryMessages.DiagnosticResponse getDefaultInstanceForType() {
5132         return com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
5133       }
5134
5135       public com.openxc.BinaryMessages.DiagnosticResponse build() {
5136         com.openxc.BinaryMessages.DiagnosticResponse result = buildPartial();
5137         if (!result.isInitialized()) {
5138           throw newUninitializedMessageException(result);
5139         }
5140         return result;
5141       }
5142
5143       public com.openxc.BinaryMessages.DiagnosticResponse buildPartial() {
5144         com.openxc.BinaryMessages.DiagnosticResponse result = new com.openxc.BinaryMessages.DiagnosticResponse(this);
5145         int from_bitField0_ = bitField0_;
5146         int to_bitField0_ = 0;
5147         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
5148           to_bitField0_ |= 0x00000001;
5149         }
5150         result.bus_ = bus_;
5151         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
5152           to_bitField0_ |= 0x00000002;
5153         }
5154         result.messageId_ = messageId_;
5155         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
5156           to_bitField0_ |= 0x00000004;
5157         }
5158         result.mode_ = mode_;
5159         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
5160           to_bitField0_ |= 0x00000008;
5161         }
5162         result.pid_ = pid_;
5163         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
5164           to_bitField0_ |= 0x00000010;
5165         }
5166         result.success_ = success_;
5167         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
5168           to_bitField0_ |= 0x00000020;
5169         }
5170         result.negativeResponseCode_ = negativeResponseCode_;
5171         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
5172           to_bitField0_ |= 0x00000040;
5173         }
5174         result.payload_ = payload_;
5175         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
5176           to_bitField0_ |= 0x00000080;
5177         }
5178         result.value_ = value_;
5179         result.bitField0_ = to_bitField0_;
5180         onBuilt();
5181         return result;
5182       }
5183
5184       public Builder mergeFrom(com.google.protobuf.Message other) {
5185         if (other instanceof com.openxc.BinaryMessages.DiagnosticResponse) {
5186           return mergeFrom((com.openxc.BinaryMessages.DiagnosticResponse)other);
5187         } else {
5188           super.mergeFrom(other);
5189           return this;
5190         }
5191       }
5192
5193       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticResponse other) {
5194         if (other == com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance()) return this;
5195         if (other.hasBus()) {
5196           setBus(other.getBus());
5197         }
5198         if (other.hasMessageId()) {
5199           setMessageId(other.getMessageId());
5200         }
5201         if (other.hasMode()) {
5202           setMode(other.getMode());
5203         }
5204         if (other.hasPid()) {
5205           setPid(other.getPid());
5206         }
5207         if (other.hasSuccess()) {
5208           setSuccess(other.getSuccess());
5209         }
5210         if (other.hasNegativeResponseCode()) {
5211           setNegativeResponseCode(other.getNegativeResponseCode());
5212         }
5213         if (other.hasPayload()) {
5214           setPayload(other.getPayload());
5215         }
5216         if (other.hasValue()) {
5217           setValue(other.getValue());
5218         }
5219         this.mergeUnknownFields(other.getUnknownFields());
5220         return this;
5221       }
5222
5223       public final boolean isInitialized() {
5224         return true;
5225       }
5226
5227       public Builder mergeFrom(
5228           com.google.protobuf.CodedInputStream input,
5229           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5230           throws java.io.IOException {
5231         com.openxc.BinaryMessages.DiagnosticResponse parsedMessage = null;
5232         try {
5233           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
5234         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5235           parsedMessage = (com.openxc.BinaryMessages.DiagnosticResponse) e.getUnfinishedMessage();
5236           throw e;
5237         } finally {
5238           if (parsedMessage != null) {
5239             mergeFrom(parsedMessage);
5240           }
5241         }
5242         return this;
5243       }
5244       private int bitField0_;
5245
5246       // optional int32 bus = 1;
5247       private int bus_ ;
5248       /**
5249        * <code>optional int32 bus = 1;</code>
5250        */
5251       public boolean hasBus() {
5252         return ((bitField0_ & 0x00000001) == 0x00000001);
5253       }
5254       /**
5255        * <code>optional int32 bus = 1;</code>
5256        */
5257       public int getBus() {
5258         return bus_;
5259       }
5260       /**
5261        * <code>optional int32 bus = 1;</code>
5262        */
5263       public Builder setBus(int value) {
5264         bitField0_ |= 0x00000001;
5265         bus_ = value;
5266         onChanged();
5267         return this;
5268       }
5269       /**
5270        * <code>optional int32 bus = 1;</code>
5271        */
5272       public Builder clearBus() {
5273         bitField0_ = (bitField0_ & ~0x00000001);
5274         bus_ = 0;
5275         onChanged();
5276         return this;
5277       }
5278
5279       // optional uint32 message_id = 2;
5280       private int messageId_ ;
5281       /**
5282        * <code>optional uint32 message_id = 2;</code>
5283        */
5284       public boolean hasMessageId() {
5285         return ((bitField0_ & 0x00000002) == 0x00000002);
5286       }
5287       /**
5288        * <code>optional uint32 message_id = 2;</code>
5289        */
5290       public int getMessageId() {
5291         return messageId_;
5292       }
5293       /**
5294        * <code>optional uint32 message_id = 2;</code>
5295        */
5296       public Builder setMessageId(int value) {
5297         bitField0_ |= 0x00000002;
5298         messageId_ = value;
5299         onChanged();
5300         return this;
5301       }
5302       /**
5303        * <code>optional uint32 message_id = 2;</code>
5304        */
5305       public Builder clearMessageId() {
5306         bitField0_ = (bitField0_ & ~0x00000002);
5307         messageId_ = 0;
5308         onChanged();
5309         return this;
5310       }
5311
5312       // optional uint32 mode = 3;
5313       private int mode_ ;
5314       /**
5315        * <code>optional uint32 mode = 3;</code>
5316        */
5317       public boolean hasMode() {
5318         return ((bitField0_ & 0x00000004) == 0x00000004);
5319       }
5320       /**
5321        * <code>optional uint32 mode = 3;</code>
5322        */
5323       public int getMode() {
5324         return mode_;
5325       }
5326       /**
5327        * <code>optional uint32 mode = 3;</code>
5328        */
5329       public Builder setMode(int value) {
5330         bitField0_ |= 0x00000004;
5331         mode_ = value;
5332         onChanged();
5333         return this;
5334       }
5335       /**
5336        * <code>optional uint32 mode = 3;</code>
5337        */
5338       public Builder clearMode() {
5339         bitField0_ = (bitField0_ & ~0x00000004);
5340         mode_ = 0;
5341         onChanged();
5342         return this;
5343       }
5344
5345       // optional uint32 pid = 4;
5346       private int pid_ ;
5347       /**
5348        * <code>optional uint32 pid = 4;</code>
5349        */
5350       public boolean hasPid() {
5351         return ((bitField0_ & 0x00000008) == 0x00000008);
5352       }
5353       /**
5354        * <code>optional uint32 pid = 4;</code>
5355        */
5356       public int getPid() {
5357         return pid_;
5358       }
5359       /**
5360        * <code>optional uint32 pid = 4;</code>
5361        */
5362       public Builder setPid(int value) {
5363         bitField0_ |= 0x00000008;
5364         pid_ = value;
5365         onChanged();
5366         return this;
5367       }
5368       /**
5369        * <code>optional uint32 pid = 4;</code>
5370        */
5371       public Builder clearPid() {
5372         bitField0_ = (bitField0_ & ~0x00000008);
5373         pid_ = 0;
5374         onChanged();
5375         return this;
5376       }
5377
5378       // optional bool success = 5;
5379       private boolean success_ ;
5380       /**
5381        * <code>optional bool success = 5;</code>
5382        */
5383       public boolean hasSuccess() {
5384         return ((bitField0_ & 0x00000010) == 0x00000010);
5385       }
5386       /**
5387        * <code>optional bool success = 5;</code>
5388        */
5389       public boolean getSuccess() {
5390         return success_;
5391       }
5392       /**
5393        * <code>optional bool success = 5;</code>
5394        */
5395       public Builder setSuccess(boolean value) {
5396         bitField0_ |= 0x00000010;
5397         success_ = value;
5398         onChanged();
5399         return this;
5400       }
5401       /**
5402        * <code>optional bool success = 5;</code>
5403        */
5404       public Builder clearSuccess() {
5405         bitField0_ = (bitField0_ & ~0x00000010);
5406         success_ = false;
5407         onChanged();
5408         return this;
5409       }
5410
5411       // optional uint32 negative_response_code = 6;
5412       private int negativeResponseCode_ ;
5413       /**
5414        * <code>optional uint32 negative_response_code = 6;</code>
5415        */
5416       public boolean hasNegativeResponseCode() {
5417         return ((bitField0_ & 0x00000020) == 0x00000020);
5418       }
5419       /**
5420        * <code>optional uint32 negative_response_code = 6;</code>
5421        */
5422       public int getNegativeResponseCode() {
5423         return negativeResponseCode_;
5424       }
5425       /**
5426        * <code>optional uint32 negative_response_code = 6;</code>
5427        */
5428       public Builder setNegativeResponseCode(int value) {
5429         bitField0_ |= 0x00000020;
5430         negativeResponseCode_ = value;
5431         onChanged();
5432         return this;
5433       }
5434       /**
5435        * <code>optional uint32 negative_response_code = 6;</code>
5436        */
5437       public Builder clearNegativeResponseCode() {
5438         bitField0_ = (bitField0_ & ~0x00000020);
5439         negativeResponseCode_ = 0;
5440         onChanged();
5441         return this;
5442       }
5443
5444       // optional bytes payload = 7;
5445       private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY;
5446       /**
5447        * <code>optional bytes payload = 7;</code>
5448        *
5449        * <pre>
5450        * TODO we are capping this at 8 bytes for now - need to change when we
5451        * support multi-frame responses
5452        * </pre>
5453        */
5454       public boolean hasPayload() {
5455         return ((bitField0_ & 0x00000040) == 0x00000040);
5456       }
5457       /**
5458        * <code>optional bytes payload = 7;</code>
5459        *
5460        * <pre>
5461        * TODO we are capping this at 8 bytes for now - need to change when we
5462        * support multi-frame responses
5463        * </pre>
5464        */
5465       public com.google.protobuf.ByteString getPayload() {
5466         return payload_;
5467       }
5468       /**
5469        * <code>optional bytes payload = 7;</code>
5470        *
5471        * <pre>
5472        * TODO we are capping this at 8 bytes for now - need to change when we
5473        * support multi-frame responses
5474        * </pre>
5475        */
5476       public Builder setPayload(com.google.protobuf.ByteString value) {
5477         if (value == null) {
5478     throw new NullPointerException();
5479   }
5480   bitField0_ |= 0x00000040;
5481         payload_ = value;
5482         onChanged();
5483         return this;
5484       }
5485       /**
5486        * <code>optional bytes payload = 7;</code>
5487        *
5488        * <pre>
5489        * TODO we are capping this at 8 bytes for now - need to change when we
5490        * support multi-frame responses
5491        * </pre>
5492        */
5493       public Builder clearPayload() {
5494         bitField0_ = (bitField0_ & ~0x00000040);
5495         payload_ = getDefaultInstance().getPayload();
5496         onChanged();
5497         return this;
5498       }
5499
5500       // optional double value = 8;
5501       private double value_ ;
5502       /**
5503        * <code>optional double value = 8;</code>
5504        */
5505       public boolean hasValue() {
5506         return ((bitField0_ & 0x00000080) == 0x00000080);
5507       }
5508       /**
5509        * <code>optional double value = 8;</code>
5510        */
5511       public double getValue() {
5512         return value_;
5513       }
5514       /**
5515        * <code>optional double value = 8;</code>
5516        */
5517       public Builder setValue(double value) {
5518         bitField0_ |= 0x00000080;
5519         value_ = value;
5520         onChanged();
5521         return this;
5522       }
5523       /**
5524        * <code>optional double value = 8;</code>
5525        */
5526       public Builder clearValue() {
5527         bitField0_ = (bitField0_ & ~0x00000080);
5528         value_ = 0D;
5529         onChanged();
5530         return this;
5531       }
5532
5533       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticResponse)
5534     }
5535
5536     static {
5537       defaultInstance = new DiagnosticResponse(true);
5538       defaultInstance.initFields();
5539     }
5540
5541     // @@protoc_insertion_point(class_scope:openxc.DiagnosticResponse)
5542   }
5543
5544   public interface DynamicFieldOrBuilder
5545       extends com.google.protobuf.MessageOrBuilder {
5546
5547     // optional .openxc.DynamicField.Type type = 1;
5548     /**
5549      * <code>optional .openxc.DynamicField.Type type = 1;</code>
5550      */
5551     boolean hasType();
5552     /**
5553      * <code>optional .openxc.DynamicField.Type type = 1;</code>
5554      */
5555     com.openxc.BinaryMessages.DynamicField.Type getType();
5556
5557     // optional string string_value = 2;
5558     /**
5559      * <code>optional string string_value = 2;</code>
5560      */
5561     boolean hasStringValue();
5562     /**
5563      * <code>optional string string_value = 2;</code>
5564      */
5565     java.lang.String getStringValue();
5566     /**
5567      * <code>optional string string_value = 2;</code>
5568      */
5569     com.google.protobuf.ByteString
5570         getStringValueBytes();
5571
5572     // optional double numeric_value = 3;
5573     /**
5574      * <code>optional double numeric_value = 3;</code>
5575      */
5576     boolean hasNumericValue();
5577     /**
5578      * <code>optional double numeric_value = 3;</code>
5579      */
5580     double getNumericValue();
5581
5582     // optional bool boolean_value = 4;
5583     /**
5584      * <code>optional bool boolean_value = 4;</code>
5585      */
5586     boolean hasBooleanValue();
5587     /**
5588      * <code>optional bool boolean_value = 4;</code>
5589      */
5590     boolean getBooleanValue();
5591   }
5592   /**
5593    * Protobuf type {@code openxc.DynamicField}
5594    */
5595   public static final class DynamicField extends
5596       com.google.protobuf.GeneratedMessage
5597       implements DynamicFieldOrBuilder {
5598     // Use DynamicField.newBuilder() to construct.
5599     private DynamicField(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
5600       super(builder);
5601       this.unknownFields = builder.getUnknownFields();
5602     }
5603     private DynamicField(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
5604
5605     private static final DynamicField defaultInstance;
5606     public static DynamicField getDefaultInstance() {
5607       return defaultInstance;
5608     }
5609
5610     public DynamicField getDefaultInstanceForType() {
5611       return defaultInstance;
5612     }
5613
5614     private final com.google.protobuf.UnknownFieldSet unknownFields;
5615     @java.lang.Override
5616     public final com.google.protobuf.UnknownFieldSet
5617         getUnknownFields() {
5618       return this.unknownFields;
5619     }
5620     private DynamicField(
5621         com.google.protobuf.CodedInputStream input,
5622         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5623         throws com.google.protobuf.InvalidProtocolBufferException {
5624       initFields();
5625       int mutable_bitField0_ = 0;
5626       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
5627           com.google.protobuf.UnknownFieldSet.newBuilder();
5628       try {
5629         boolean done = false;
5630         while (!done) {
5631           int tag = input.readTag();
5632           switch (tag) {
5633             case 0:
5634               done = true;
5635               break;
5636             default: {
5637               if (!parseUnknownField(input, unknownFields,
5638                                      extensionRegistry, tag)) {
5639                 done = true;
5640               }
5641               break;
5642             }
5643             case 8: {
5644               int rawValue = input.readEnum();
5645               com.openxc.BinaryMessages.DynamicField.Type value = com.openxc.BinaryMessages.DynamicField.Type.valueOf(rawValue);
5646               if (value == null) {
5647                 unknownFields.mergeVarintField(1, rawValue);
5648               } else {
5649                 bitField0_ |= 0x00000001;
5650                 type_ = value;
5651               }
5652               break;
5653             }
5654             case 18: {
5655               bitField0_ |= 0x00000002;
5656               stringValue_ = input.readBytes();
5657               break;
5658             }
5659             case 25: {
5660               bitField0_ |= 0x00000004;
5661               numericValue_ = input.readDouble();
5662               break;
5663             }
5664             case 32: {
5665               bitField0_ |= 0x00000008;
5666               booleanValue_ = input.readBool();
5667               break;
5668             }
5669           }
5670         }
5671       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5672         throw e.setUnfinishedMessage(this);
5673       } catch (java.io.IOException e) {
5674         throw new com.google.protobuf.InvalidProtocolBufferException(
5675             e.getMessage()).setUnfinishedMessage(this);
5676       } finally {
5677         this.unknownFields = unknownFields.build();
5678         makeExtensionsImmutable();
5679       }
5680     }
5681     public static final com.google.protobuf.Descriptors.Descriptor
5682         getDescriptor() {
5683       return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
5684     }
5685
5686     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5687         internalGetFieldAccessorTable() {
5688       return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_fieldAccessorTable
5689           .ensureFieldAccessorsInitialized(
5690               com.openxc.BinaryMessages.DynamicField.class, com.openxc.BinaryMessages.DynamicField.Builder.class);
5691     }
5692
5693     public static com.google.protobuf.Parser<DynamicField> PARSER =
5694         new com.google.protobuf.AbstractParser<DynamicField>() {
5695       public DynamicField parsePartialFrom(
5696           com.google.protobuf.CodedInputStream input,
5697           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5698           throws com.google.protobuf.InvalidProtocolBufferException {
5699         return new DynamicField(input, extensionRegistry);
5700       }
5701     };
5702
5703     @java.lang.Override
5704     public com.google.protobuf.Parser<DynamicField> getParserForType() {
5705       return PARSER;
5706     }
5707
5708     /**
5709      * Protobuf enum {@code openxc.DynamicField.Type}
5710      */
5711     public enum Type
5712         implements com.google.protobuf.ProtocolMessageEnum {
5713       /**
5714        * <code>STRING = 1;</code>
5715        */
5716       STRING(0, 1),
5717       /**
5718        * <code>NUM = 2;</code>
5719        */
5720       NUM(1, 2),
5721       /**
5722        * <code>BOOL = 3;</code>
5723        */
5724       BOOL(2, 3),
5725       ;
5726
5727       /**
5728        * <code>STRING = 1;</code>
5729        */
5730       public static final int STRING_VALUE = 1;
5731       /**
5732        * <code>NUM = 2;</code>
5733        */
5734       public static final int NUM_VALUE = 2;
5735       /**
5736        * <code>BOOL = 3;</code>
5737        */
5738       public static final int BOOL_VALUE = 3;
5739
5740
5741       public final int getNumber() { return value; }
5742
5743       public static Type valueOf(int value) {
5744         switch (value) {
5745           case 1: return STRING;
5746           case 2: return NUM;
5747           case 3: return BOOL;
5748           default: return null;
5749         }
5750       }
5751
5752       public static com.google.protobuf.Internal.EnumLiteMap<Type>
5753           internalGetValueMap() {
5754         return internalValueMap;
5755       }
5756       private static com.google.protobuf.Internal.EnumLiteMap<Type>
5757           internalValueMap =
5758             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
5759               public Type findValueByNumber(int number) {
5760                 return Type.valueOf(number);
5761               }
5762             };
5763
5764       public final com.google.protobuf.Descriptors.EnumValueDescriptor
5765           getValueDescriptor() {
5766         return getDescriptor().getValues().get(index);
5767       }
5768       public final com.google.protobuf.Descriptors.EnumDescriptor
5769           getDescriptorForType() {
5770         return getDescriptor();
5771       }
5772       public static final com.google.protobuf.Descriptors.EnumDescriptor
5773           getDescriptor() {
5774         return com.openxc.BinaryMessages.DynamicField.getDescriptor().getEnumTypes().get(0);
5775       }
5776
5777       private static final Type[] VALUES = values();
5778
5779       public static Type valueOf(
5780           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
5781         if (desc.getType() != getDescriptor()) {
5782           throw new java.lang.IllegalArgumentException(
5783             "EnumValueDescriptor is not for this type.");
5784         }
5785         return VALUES[desc.getIndex()];
5786       }
5787
5788       private final int index;
5789       private final int value;
5790
5791       private Type(int index, int value) {
5792         this.index = index;
5793         this.value = value;
5794       }
5795
5796       // @@protoc_insertion_point(enum_scope:openxc.DynamicField.Type)
5797     }
5798
5799     private int bitField0_;
5800     // optional .openxc.DynamicField.Type type = 1;
5801     public static final int TYPE_FIELD_NUMBER = 1;
5802     private com.openxc.BinaryMessages.DynamicField.Type type_;
5803     /**
5804      * <code>optional .openxc.DynamicField.Type type = 1;</code>
5805      */
5806     public boolean hasType() {
5807       return ((bitField0_ & 0x00000001) == 0x00000001);
5808     }
5809     /**
5810      * <code>optional .openxc.DynamicField.Type type = 1;</code>
5811      */
5812     public com.openxc.BinaryMessages.DynamicField.Type getType() {
5813       return type_;
5814     }
5815
5816     // optional string string_value = 2;
5817     public static final int STRING_VALUE_FIELD_NUMBER = 2;
5818     private java.lang.Object stringValue_;
5819     /**
5820      * <code>optional string string_value = 2;</code>
5821      */
5822     public boolean hasStringValue() {
5823       return ((bitField0_ & 0x00000002) == 0x00000002);
5824     }
5825     /**
5826      * <code>optional string string_value = 2;</code>
5827      */
5828     public java.lang.String getStringValue() {
5829       java.lang.Object ref = stringValue_;
5830       if (ref instanceof java.lang.String) {
5831         return (java.lang.String) ref;
5832       } else {
5833         com.google.protobuf.ByteString bs = 
5834             (com.google.protobuf.ByteString) ref;
5835         java.lang.String s = bs.toStringUtf8();
5836         if (bs.isValidUtf8()) {
5837           stringValue_ = s;
5838         }
5839         return s;
5840       }
5841     }
5842     /**
5843      * <code>optional string string_value = 2;</code>
5844      */
5845     public com.google.protobuf.ByteString
5846         getStringValueBytes() {
5847       java.lang.Object ref = stringValue_;
5848       if (ref instanceof java.lang.String) {
5849         com.google.protobuf.ByteString b = 
5850             com.google.protobuf.ByteString.copyFromUtf8(
5851                 (java.lang.String) ref);
5852         stringValue_ = b;
5853         return b;
5854       } else {
5855         return (com.google.protobuf.ByteString) ref;
5856       }
5857     }
5858
5859     // optional double numeric_value = 3;
5860     public static final int NUMERIC_VALUE_FIELD_NUMBER = 3;
5861     private double numericValue_;
5862     /**
5863      * <code>optional double numeric_value = 3;</code>
5864      */
5865     public boolean hasNumericValue() {
5866       return ((bitField0_ & 0x00000004) == 0x00000004);
5867     }
5868     /**
5869      * <code>optional double numeric_value = 3;</code>
5870      */
5871     public double getNumericValue() {
5872       return numericValue_;
5873     }
5874
5875     // optional bool boolean_value = 4;
5876     public static final int BOOLEAN_VALUE_FIELD_NUMBER = 4;
5877     private boolean booleanValue_;
5878     /**
5879      * <code>optional bool boolean_value = 4;</code>
5880      */
5881     public boolean hasBooleanValue() {
5882       return ((bitField0_ & 0x00000008) == 0x00000008);
5883     }
5884     /**
5885      * <code>optional bool boolean_value = 4;</code>
5886      */
5887     public boolean getBooleanValue() {
5888       return booleanValue_;
5889     }
5890
5891     private void initFields() {
5892       type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
5893       stringValue_ = "";
5894       numericValue_ = 0D;
5895       booleanValue_ = false;
5896     }
5897     private byte memoizedIsInitialized = -1;
5898     public final boolean isInitialized() {
5899       byte isInitialized = memoizedIsInitialized;
5900       if (isInitialized != -1) return isInitialized == 1;
5901
5902       memoizedIsInitialized = 1;
5903       return true;
5904     }
5905
5906     public void writeTo(com.google.protobuf.CodedOutputStream output)
5907                         throws java.io.IOException {
5908       getSerializedSize();
5909       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5910         output.writeEnum(1, type_.getNumber());
5911       }
5912       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5913         output.writeBytes(2, getStringValueBytes());
5914       }
5915       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5916         output.writeDouble(3, numericValue_);
5917       }
5918       if (((bitField0_ & 0x00000008) == 0x00000008)) {
5919         output.writeBool(4, booleanValue_);
5920       }
5921       getUnknownFields().writeTo(output);
5922     }
5923
5924     private int memoizedSerializedSize = -1;
5925     public int getSerializedSize() {
5926       int size = memoizedSerializedSize;
5927       if (size != -1) return size;
5928
5929       size = 0;
5930       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5931         size += com.google.protobuf.CodedOutputStream
5932           .computeEnumSize(1, type_.getNumber());
5933       }
5934       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5935         size += com.google.protobuf.CodedOutputStream
5936           .computeBytesSize(2, getStringValueBytes());
5937       }
5938       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5939         size += com.google.protobuf.CodedOutputStream
5940           .computeDoubleSize(3, numericValue_);
5941       }
5942       if (((bitField0_ & 0x00000008) == 0x00000008)) {
5943         size += com.google.protobuf.CodedOutputStream
5944           .computeBoolSize(4, booleanValue_);
5945       }
5946       size += getUnknownFields().getSerializedSize();
5947       memoizedSerializedSize = size;
5948       return size;
5949     }
5950
5951     private static final long serialVersionUID = 0L;
5952     @java.lang.Override
5953     protected java.lang.Object writeReplace()
5954         throws java.io.ObjectStreamException {
5955       return super.writeReplace();
5956     }
5957
5958     public static com.openxc.BinaryMessages.DynamicField parseFrom(
5959         com.google.protobuf.ByteString data)
5960         throws com.google.protobuf.InvalidProtocolBufferException {
5961       return PARSER.parseFrom(data);
5962     }
5963     public static com.openxc.BinaryMessages.DynamicField parseFrom(
5964         com.google.protobuf.ByteString data,
5965         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5966         throws com.google.protobuf.InvalidProtocolBufferException {
5967       return PARSER.parseFrom(data, extensionRegistry);
5968     }
5969     public static com.openxc.BinaryMessages.DynamicField parseFrom(byte[] data)
5970         throws com.google.protobuf.InvalidProtocolBufferException {
5971       return PARSER.parseFrom(data);
5972     }
5973     public static com.openxc.BinaryMessages.DynamicField parseFrom(
5974         byte[] data,
5975         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5976         throws com.google.protobuf.InvalidProtocolBufferException {
5977       return PARSER.parseFrom(data, extensionRegistry);
5978     }
5979     public static com.openxc.BinaryMessages.DynamicField parseFrom(java.io.InputStream input)
5980         throws java.io.IOException {
5981       return PARSER.parseFrom(input);
5982     }
5983     public static com.openxc.BinaryMessages.DynamicField parseFrom(
5984         java.io.InputStream input,
5985         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5986         throws java.io.IOException {
5987       return PARSER.parseFrom(input, extensionRegistry);
5988     }
5989     public static com.openxc.BinaryMessages.DynamicField parseDelimitedFrom(java.io.InputStream input)
5990         throws java.io.IOException {
5991       return PARSER.parseDelimitedFrom(input);
5992     }
5993     public static com.openxc.BinaryMessages.DynamicField parseDelimitedFrom(
5994         java.io.InputStream input,
5995         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5996         throws java.io.IOException {
5997       return PARSER.parseDelimitedFrom(input, extensionRegistry);
5998     }
5999     public static com.openxc.BinaryMessages.DynamicField parseFrom(
6000         com.google.protobuf.CodedInputStream input)
6001         throws java.io.IOException {
6002       return PARSER.parseFrom(input);
6003     }
6004     public static com.openxc.BinaryMessages.DynamicField parseFrom(
6005         com.google.protobuf.CodedInputStream input,
6006         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6007         throws java.io.IOException {
6008       return PARSER.parseFrom(input, extensionRegistry);
6009     }
6010
6011     public static Builder newBuilder() { return Builder.create(); }
6012     public Builder newBuilderForType() { return newBuilder(); }
6013     public static Builder newBuilder(com.openxc.BinaryMessages.DynamicField prototype) {
6014       return newBuilder().mergeFrom(prototype);
6015     }
6016     public Builder toBuilder() { return newBuilder(this); }
6017
6018     @java.lang.Override
6019     protected Builder newBuilderForType(
6020         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6021       Builder builder = new Builder(parent);
6022       return builder;
6023     }
6024     /**
6025      * Protobuf type {@code openxc.DynamicField}
6026      */
6027     public static final class Builder extends
6028         com.google.protobuf.GeneratedMessage.Builder<Builder>
6029        implements com.openxc.BinaryMessages.DynamicFieldOrBuilder {
6030       public static final com.google.protobuf.Descriptors.Descriptor
6031           getDescriptor() {
6032         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
6033       }
6034
6035       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6036           internalGetFieldAccessorTable() {
6037         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_fieldAccessorTable
6038             .ensureFieldAccessorsInitialized(
6039                 com.openxc.BinaryMessages.DynamicField.class, com.openxc.BinaryMessages.DynamicField.Builder.class);
6040       }
6041
6042       // Construct using com.openxc.BinaryMessages.DynamicField.newBuilder()
6043       private Builder() {
6044         maybeForceBuilderInitialization();
6045       }
6046
6047       private Builder(
6048           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6049         super(parent);
6050         maybeForceBuilderInitialization();
6051       }
6052       private void maybeForceBuilderInitialization() {
6053         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
6054         }
6055       }
6056       private static Builder create() {
6057         return new Builder();
6058       }
6059
6060       public Builder clear() {
6061         super.clear();
6062         type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
6063         bitField0_ = (bitField0_ & ~0x00000001);
6064         stringValue_ = "";
6065         bitField0_ = (bitField0_ & ~0x00000002);
6066         numericValue_ = 0D;
6067         bitField0_ = (bitField0_ & ~0x00000004);
6068         booleanValue_ = false;
6069         bitField0_ = (bitField0_ & ~0x00000008);
6070         return this;
6071       }
6072
6073       public Builder clone() {
6074         return create().mergeFrom(buildPartial());
6075       }
6076
6077       public com.google.protobuf.Descriptors.Descriptor
6078           getDescriptorForType() {
6079         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
6080       }
6081
6082       public com.openxc.BinaryMessages.DynamicField getDefaultInstanceForType() {
6083         return com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
6084       }
6085
6086       public com.openxc.BinaryMessages.DynamicField build() {
6087         com.openxc.BinaryMessages.DynamicField result = buildPartial();
6088         if (!result.isInitialized()) {
6089           throw newUninitializedMessageException(result);
6090         }
6091         return result;
6092       }
6093
6094       public com.openxc.BinaryMessages.DynamicField buildPartial() {
6095         com.openxc.BinaryMessages.DynamicField result = new com.openxc.BinaryMessages.DynamicField(this);
6096         int from_bitField0_ = bitField0_;
6097         int to_bitField0_ = 0;
6098         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
6099           to_bitField0_ |= 0x00000001;
6100         }
6101         result.type_ = type_;
6102         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
6103           to_bitField0_ |= 0x00000002;
6104         }
6105         result.stringValue_ = stringValue_;
6106         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
6107           to_bitField0_ |= 0x00000004;
6108         }
6109         result.numericValue_ = numericValue_;
6110         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
6111           to_bitField0_ |= 0x00000008;
6112         }
6113         result.booleanValue_ = booleanValue_;
6114         result.bitField0_ = to_bitField0_;
6115         onBuilt();
6116         return result;
6117       }
6118
6119       public Builder mergeFrom(com.google.protobuf.Message other) {
6120         if (other instanceof com.openxc.BinaryMessages.DynamicField) {
6121           return mergeFrom((com.openxc.BinaryMessages.DynamicField)other);
6122         } else {
6123           super.mergeFrom(other);
6124           return this;
6125         }
6126       }
6127
6128       public Builder mergeFrom(com.openxc.BinaryMessages.DynamicField other) {
6129         if (other == com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) return this;
6130         if (other.hasType()) {
6131           setType(other.getType());
6132         }
6133         if (other.hasStringValue()) {
6134           bitField0_ |= 0x00000002;
6135           stringValue_ = other.stringValue_;
6136           onChanged();
6137         }
6138         if (other.hasNumericValue()) {
6139           setNumericValue(other.getNumericValue());
6140         }
6141         if (other.hasBooleanValue()) {
6142           setBooleanValue(other.getBooleanValue());
6143         }
6144         this.mergeUnknownFields(other.getUnknownFields());
6145         return this;
6146       }
6147
6148       public final boolean isInitialized() {
6149         return true;
6150       }
6151
6152       public Builder mergeFrom(
6153           com.google.protobuf.CodedInputStream input,
6154           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6155           throws java.io.IOException {
6156         com.openxc.BinaryMessages.DynamicField parsedMessage = null;
6157         try {
6158           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
6159         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
6160           parsedMessage = (com.openxc.BinaryMessages.DynamicField) e.getUnfinishedMessage();
6161           throw e;
6162         } finally {
6163           if (parsedMessage != null) {
6164             mergeFrom(parsedMessage);
6165           }
6166         }
6167         return this;
6168       }
6169       private int bitField0_;
6170
6171       // optional .openxc.DynamicField.Type type = 1;
6172       private com.openxc.BinaryMessages.DynamicField.Type type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
6173       /**
6174        * <code>optional .openxc.DynamicField.Type type = 1;</code>
6175        */
6176       public boolean hasType() {
6177         return ((bitField0_ & 0x00000001) == 0x00000001);
6178       }
6179       /**
6180        * <code>optional .openxc.DynamicField.Type type = 1;</code>
6181        */
6182       public com.openxc.BinaryMessages.DynamicField.Type getType() {
6183         return type_;
6184       }
6185       /**
6186        * <code>optional .openxc.DynamicField.Type type = 1;</code>
6187        */
6188       public Builder setType(com.openxc.BinaryMessages.DynamicField.Type value) {
6189         if (value == null) {
6190           throw new NullPointerException();
6191         }
6192         bitField0_ |= 0x00000001;
6193         type_ = value;
6194         onChanged();
6195         return this;
6196       }
6197       /**
6198        * <code>optional .openxc.DynamicField.Type type = 1;</code>
6199        */
6200       public Builder clearType() {
6201         bitField0_ = (bitField0_ & ~0x00000001);
6202         type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
6203         onChanged();
6204         return this;
6205       }
6206
6207       // optional string string_value = 2;
6208       private java.lang.Object stringValue_ = "";
6209       /**
6210        * <code>optional string string_value = 2;</code>
6211        */
6212       public boolean hasStringValue() {
6213         return ((bitField0_ & 0x00000002) == 0x00000002);
6214       }
6215       /**
6216        * <code>optional string string_value = 2;</code>
6217        */
6218       public java.lang.String getStringValue() {
6219         java.lang.Object ref = stringValue_;
6220         if (!(ref instanceof java.lang.String)) {
6221           java.lang.String s = ((com.google.protobuf.ByteString) ref)
6222               .toStringUtf8();
6223           stringValue_ = s;
6224           return s;
6225         } else {
6226           return (java.lang.String) ref;
6227         }
6228       }
6229       /**
6230        * <code>optional string string_value = 2;</code>
6231        */
6232       public com.google.protobuf.ByteString
6233           getStringValueBytes() {
6234         java.lang.Object ref = stringValue_;
6235         if (ref instanceof String) {
6236           com.google.protobuf.ByteString b = 
6237               com.google.protobuf.ByteString.copyFromUtf8(
6238                   (java.lang.String) ref);
6239           stringValue_ = b;
6240           return b;
6241         } else {
6242           return (com.google.protobuf.ByteString) ref;
6243         }
6244       }
6245       /**
6246        * <code>optional string string_value = 2;</code>
6247        */
6248       public Builder setStringValue(
6249           java.lang.String value) {
6250         if (value == null) {
6251     throw new NullPointerException();
6252   }
6253   bitField0_ |= 0x00000002;
6254         stringValue_ = value;
6255         onChanged();
6256         return this;
6257       }
6258       /**
6259        * <code>optional string string_value = 2;</code>
6260        */
6261       public Builder clearStringValue() {
6262         bitField0_ = (bitField0_ & ~0x00000002);
6263         stringValue_ = getDefaultInstance().getStringValue();
6264         onChanged();
6265         return this;
6266       }
6267       /**
6268        * <code>optional string string_value = 2;</code>
6269        */
6270       public Builder setStringValueBytes(
6271           com.google.protobuf.ByteString value) {
6272         if (value == null) {
6273     throw new NullPointerException();
6274   }
6275   bitField0_ |= 0x00000002;
6276         stringValue_ = value;
6277         onChanged();
6278         return this;
6279       }
6280
6281       // optional double numeric_value = 3;
6282       private double numericValue_ ;
6283       /**
6284        * <code>optional double numeric_value = 3;</code>
6285        */
6286       public boolean hasNumericValue() {
6287         return ((bitField0_ & 0x00000004) == 0x00000004);
6288       }
6289       /**
6290        * <code>optional double numeric_value = 3;</code>
6291        */
6292       public double getNumericValue() {
6293         return numericValue_;
6294       }
6295       /**
6296        * <code>optional double numeric_value = 3;</code>
6297        */
6298       public Builder setNumericValue(double value) {
6299         bitField0_ |= 0x00000004;
6300         numericValue_ = value;
6301         onChanged();
6302         return this;
6303       }
6304       /**
6305        * <code>optional double numeric_value = 3;</code>
6306        */
6307       public Builder clearNumericValue() {
6308         bitField0_ = (bitField0_ & ~0x00000004);
6309         numericValue_ = 0D;
6310         onChanged();
6311         return this;
6312       }
6313
6314       // optional bool boolean_value = 4;
6315       private boolean booleanValue_ ;
6316       /**
6317        * <code>optional bool boolean_value = 4;</code>
6318        */
6319       public boolean hasBooleanValue() {
6320         return ((bitField0_ & 0x00000008) == 0x00000008);
6321       }
6322       /**
6323        * <code>optional bool boolean_value = 4;</code>
6324        */
6325       public boolean getBooleanValue() {
6326         return booleanValue_;
6327       }
6328       /**
6329        * <code>optional bool boolean_value = 4;</code>
6330        */
6331       public Builder setBooleanValue(boolean value) {
6332         bitField0_ |= 0x00000008;
6333         booleanValue_ = value;
6334         onChanged();
6335         return this;
6336       }
6337       /**
6338        * <code>optional bool boolean_value = 4;</code>
6339        */
6340       public Builder clearBooleanValue() {
6341         bitField0_ = (bitField0_ & ~0x00000008);
6342         booleanValue_ = false;
6343         onChanged();
6344         return this;
6345       }
6346
6347       // @@protoc_insertion_point(builder_scope:openxc.DynamicField)
6348     }
6349
6350     static {
6351       defaultInstance = new DynamicField(true);
6352       defaultInstance.initFields();
6353     }
6354
6355     // @@protoc_insertion_point(class_scope:openxc.DynamicField)
6356   }
6357
6358   public interface TranslatedMessageOrBuilder
6359       extends com.google.protobuf.MessageOrBuilder {
6360
6361     // optional .openxc.TranslatedMessage.Type type = 1;
6362     /**
6363      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
6364      */
6365     boolean hasType();
6366     /**
6367      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
6368      */
6369     com.openxc.BinaryMessages.TranslatedMessage.Type getType();
6370
6371     // optional string name = 2;
6372     /**
6373      * <code>optional string name = 2;</code>
6374      */
6375     boolean hasName();
6376     /**
6377      * <code>optional string name = 2;</code>
6378      */
6379     java.lang.String getName();
6380     /**
6381      * <code>optional string name = 2;</code>
6382      */
6383     com.google.protobuf.ByteString
6384         getNameBytes();
6385
6386     // optional .openxc.DynamicField value = 3;
6387     /**
6388      * <code>optional .openxc.DynamicField value = 3;</code>
6389      */
6390     boolean hasValue();
6391     /**
6392      * <code>optional .openxc.DynamicField value = 3;</code>
6393      */
6394     com.openxc.BinaryMessages.DynamicField getValue();
6395     /**
6396      * <code>optional .openxc.DynamicField value = 3;</code>
6397      */
6398     com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder();
6399
6400     // optional .openxc.DynamicField event = 4;
6401     /**
6402      * <code>optional .openxc.DynamicField event = 4;</code>
6403      */
6404     boolean hasEvent();
6405     /**
6406      * <code>optional .openxc.DynamicField event = 4;</code>
6407      */
6408     com.openxc.BinaryMessages.DynamicField getEvent();
6409     /**
6410      * <code>optional .openxc.DynamicField event = 4;</code>
6411      */
6412     com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder();
6413   }
6414   /**
6415    * Protobuf type {@code openxc.TranslatedMessage}
6416    */
6417   public static final class TranslatedMessage extends
6418       com.google.protobuf.GeneratedMessage
6419       implements TranslatedMessageOrBuilder {
6420     // Use TranslatedMessage.newBuilder() to construct.
6421     private TranslatedMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
6422       super(builder);
6423       this.unknownFields = builder.getUnknownFields();
6424     }
6425     private TranslatedMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
6426
6427     private static final TranslatedMessage defaultInstance;
6428     public static TranslatedMessage getDefaultInstance() {
6429       return defaultInstance;
6430     }
6431
6432     public TranslatedMessage getDefaultInstanceForType() {
6433       return defaultInstance;
6434     }
6435
6436     private final com.google.protobuf.UnknownFieldSet unknownFields;
6437     @java.lang.Override
6438     public final com.google.protobuf.UnknownFieldSet
6439         getUnknownFields() {
6440       return this.unknownFields;
6441     }
6442     private TranslatedMessage(
6443         com.google.protobuf.CodedInputStream input,
6444         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6445         throws com.google.protobuf.InvalidProtocolBufferException {
6446       initFields();
6447       int mutable_bitField0_ = 0;
6448       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
6449           com.google.protobuf.UnknownFieldSet.newBuilder();
6450       try {
6451         boolean done = false;
6452         while (!done) {
6453           int tag = input.readTag();
6454           switch (tag) {
6455             case 0:
6456               done = true;
6457               break;
6458             default: {
6459               if (!parseUnknownField(input, unknownFields,
6460                                      extensionRegistry, tag)) {
6461                 done = true;
6462               }
6463               break;
6464             }
6465             case 8: {
6466               int rawValue = input.readEnum();
6467               com.openxc.BinaryMessages.TranslatedMessage.Type value = com.openxc.BinaryMessages.TranslatedMessage.Type.valueOf(rawValue);
6468               if (value == null) {
6469                 unknownFields.mergeVarintField(1, rawValue);
6470               } else {
6471                 bitField0_ |= 0x00000001;
6472                 type_ = value;
6473               }
6474               break;
6475             }
6476             case 18: {
6477               bitField0_ |= 0x00000002;
6478               name_ = input.readBytes();
6479               break;
6480             }
6481             case 26: {
6482               com.openxc.BinaryMessages.DynamicField.Builder subBuilder = null;
6483               if (((bitField0_ & 0x00000004) == 0x00000004)) {
6484                 subBuilder = value_.toBuilder();
6485               }
6486               value_ = input.readMessage(com.openxc.BinaryMessages.DynamicField.PARSER, extensionRegistry);
6487               if (subBuilder != null) {
6488                 subBuilder.mergeFrom(value_);
6489                 value_ = subBuilder.buildPartial();
6490               }
6491               bitField0_ |= 0x00000004;
6492               break;
6493             }
6494             case 34: {
6495               com.openxc.BinaryMessages.DynamicField.Builder subBuilder = null;
6496               if (((bitField0_ & 0x00000008) == 0x00000008)) {
6497                 subBuilder = event_.toBuilder();
6498               }
6499               event_ = input.readMessage(com.openxc.BinaryMessages.DynamicField.PARSER, extensionRegistry);
6500               if (subBuilder != null) {
6501                 subBuilder.mergeFrom(event_);
6502                 event_ = subBuilder.buildPartial();
6503               }
6504               bitField0_ |= 0x00000008;
6505               break;
6506             }
6507           }
6508         }
6509       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
6510         throw e.setUnfinishedMessage(this);
6511       } catch (java.io.IOException e) {
6512         throw new com.google.protobuf.InvalidProtocolBufferException(
6513             e.getMessage()).setUnfinishedMessage(this);
6514       } finally {
6515         this.unknownFields = unknownFields.build();
6516         makeExtensionsImmutable();
6517       }
6518     }
6519     public static final com.google.protobuf.Descriptors.Descriptor
6520         getDescriptor() {
6521       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
6522     }
6523
6524     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6525         internalGetFieldAccessorTable() {
6526       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
6527           .ensureFieldAccessorsInitialized(
6528               com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
6529     }
6530
6531     public static com.google.protobuf.Parser<TranslatedMessage> PARSER =
6532         new com.google.protobuf.AbstractParser<TranslatedMessage>() {
6533       public TranslatedMessage parsePartialFrom(
6534           com.google.protobuf.CodedInputStream input,
6535           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6536           throws com.google.protobuf.InvalidProtocolBufferException {
6537         return new TranslatedMessage(input, extensionRegistry);
6538       }
6539     };
6540
6541     @java.lang.Override
6542     public com.google.protobuf.Parser<TranslatedMessage> getParserForType() {
6543       return PARSER;
6544     }
6545
6546     /**
6547      * Protobuf enum {@code openxc.TranslatedMessage.Type}
6548      */
6549     public enum Type
6550         implements com.google.protobuf.ProtocolMessageEnum {
6551       /**
6552        * <code>STRING = 1;</code>
6553        */
6554       STRING(0, 1),
6555       /**
6556        * <code>NUM = 2;</code>
6557        */
6558       NUM(1, 2),
6559       /**
6560        * <code>BOOL = 3;</code>
6561        */
6562       BOOL(2, 3),
6563       /**
6564        * <code>EVENTED_STRING = 4;</code>
6565        */
6566       EVENTED_STRING(3, 4),
6567       /**
6568        * <code>EVENTED_NUM = 5;</code>
6569        */
6570       EVENTED_NUM(4, 5),
6571       /**
6572        * <code>EVENTED_BOOL = 6;</code>
6573        */
6574       EVENTED_BOOL(5, 6),
6575       ;
6576
6577       /**
6578        * <code>STRING = 1;</code>
6579        */
6580       public static final int STRING_VALUE = 1;
6581       /**
6582        * <code>NUM = 2;</code>
6583        */
6584       public static final int NUM_VALUE = 2;
6585       /**
6586        * <code>BOOL = 3;</code>
6587        */
6588       public static final int BOOL_VALUE = 3;
6589       /**
6590        * <code>EVENTED_STRING = 4;</code>
6591        */
6592       public static final int EVENTED_STRING_VALUE = 4;
6593       /**
6594        * <code>EVENTED_NUM = 5;</code>
6595        */
6596       public static final int EVENTED_NUM_VALUE = 5;
6597       /**
6598        * <code>EVENTED_BOOL = 6;</code>
6599        */
6600       public static final int EVENTED_BOOL_VALUE = 6;
6601
6602
6603       public final int getNumber() { return value; }
6604
6605       public static Type valueOf(int value) {
6606         switch (value) {
6607           case 1: return STRING;
6608           case 2: return NUM;
6609           case 3: return BOOL;
6610           case 4: return EVENTED_STRING;
6611           case 5: return EVENTED_NUM;
6612           case 6: return EVENTED_BOOL;
6613           default: return null;
6614         }
6615       }
6616
6617       public static com.google.protobuf.Internal.EnumLiteMap<Type>
6618           internalGetValueMap() {
6619         return internalValueMap;
6620       }
6621       private static com.google.protobuf.Internal.EnumLiteMap<Type>
6622           internalValueMap =
6623             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
6624               public Type findValueByNumber(int number) {
6625                 return Type.valueOf(number);
6626               }
6627             };
6628
6629       public final com.google.protobuf.Descriptors.EnumValueDescriptor
6630           getValueDescriptor() {
6631         return getDescriptor().getValues().get(index);
6632       }
6633       public final com.google.protobuf.Descriptors.EnumDescriptor
6634           getDescriptorForType() {
6635         return getDescriptor();
6636       }
6637       public static final com.google.protobuf.Descriptors.EnumDescriptor
6638           getDescriptor() {
6639         return com.openxc.BinaryMessages.TranslatedMessage.getDescriptor().getEnumTypes().get(0);
6640       }
6641
6642       private static final Type[] VALUES = values();
6643
6644       public static Type valueOf(
6645           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
6646         if (desc.getType() != getDescriptor()) {
6647           throw new java.lang.IllegalArgumentException(
6648             "EnumValueDescriptor is not for this type.");
6649         }
6650         return VALUES[desc.getIndex()];
6651       }
6652
6653       private final int index;
6654       private final int value;
6655
6656       private Type(int index, int value) {
6657         this.index = index;
6658         this.value = value;
6659       }
6660
6661       // @@protoc_insertion_point(enum_scope:openxc.TranslatedMessage.Type)
6662     }
6663
6664     private int bitField0_;
6665     // optional .openxc.TranslatedMessage.Type type = 1;
6666     public static final int TYPE_FIELD_NUMBER = 1;
6667     private com.openxc.BinaryMessages.TranslatedMessage.Type type_;
6668     /**
6669      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
6670      */
6671     public boolean hasType() {
6672       return ((bitField0_ & 0x00000001) == 0x00000001);
6673     }
6674     /**
6675      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
6676      */
6677     public com.openxc.BinaryMessages.TranslatedMessage.Type getType() {
6678       return type_;
6679     }
6680
6681     // optional string name = 2;
6682     public static final int NAME_FIELD_NUMBER = 2;
6683     private java.lang.Object name_;
6684     /**
6685      * <code>optional string name = 2;</code>
6686      */
6687     public boolean hasName() {
6688       return ((bitField0_ & 0x00000002) == 0x00000002);
6689     }
6690     /**
6691      * <code>optional string name = 2;</code>
6692      */
6693     public java.lang.String getName() {
6694       java.lang.Object ref = name_;
6695       if (ref instanceof java.lang.String) {
6696         return (java.lang.String) ref;
6697       } else {
6698         com.google.protobuf.ByteString bs = 
6699             (com.google.protobuf.ByteString) ref;
6700         java.lang.String s = bs.toStringUtf8();
6701         if (bs.isValidUtf8()) {
6702           name_ = s;
6703         }
6704         return s;
6705       }
6706     }
6707     /**
6708      * <code>optional string name = 2;</code>
6709      */
6710     public com.google.protobuf.ByteString
6711         getNameBytes() {
6712       java.lang.Object ref = name_;
6713       if (ref instanceof java.lang.String) {
6714         com.google.protobuf.ByteString b = 
6715             com.google.protobuf.ByteString.copyFromUtf8(
6716                 (java.lang.String) ref);
6717         name_ = b;
6718         return b;
6719       } else {
6720         return (com.google.protobuf.ByteString) ref;
6721       }
6722     }
6723
6724     // optional .openxc.DynamicField value = 3;
6725     public static final int VALUE_FIELD_NUMBER = 3;
6726     private com.openxc.BinaryMessages.DynamicField value_;
6727     /**
6728      * <code>optional .openxc.DynamicField value = 3;</code>
6729      */
6730     public boolean hasValue() {
6731       return ((bitField0_ & 0x00000004) == 0x00000004);
6732     }
6733     /**
6734      * <code>optional .openxc.DynamicField value = 3;</code>
6735      */
6736     public com.openxc.BinaryMessages.DynamicField getValue() {
6737       return value_;
6738     }
6739     /**
6740      * <code>optional .openxc.DynamicField value = 3;</code>
6741      */
6742     public com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder() {
6743       return value_;
6744     }
6745
6746     // optional .openxc.DynamicField event = 4;
6747     public static final int EVENT_FIELD_NUMBER = 4;
6748     private com.openxc.BinaryMessages.DynamicField event_;
6749     /**
6750      * <code>optional .openxc.DynamicField event = 4;</code>
6751      */
6752     public boolean hasEvent() {
6753       return ((bitField0_ & 0x00000008) == 0x00000008);
6754     }
6755     /**
6756      * <code>optional .openxc.DynamicField event = 4;</code>
6757      */
6758     public com.openxc.BinaryMessages.DynamicField getEvent() {
6759       return event_;
6760     }
6761     /**
6762      * <code>optional .openxc.DynamicField event = 4;</code>
6763      */
6764     public com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder() {
6765       return event_;
6766     }
6767
6768     private void initFields() {
6769       type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
6770       name_ = "";
6771       value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
6772       event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
6773     }
6774     private byte memoizedIsInitialized = -1;
6775     public final boolean isInitialized() {
6776       byte isInitialized = memoizedIsInitialized;
6777       if (isInitialized != -1) return isInitialized == 1;
6778
6779       memoizedIsInitialized = 1;
6780       return true;
6781     }
6782
6783     public void writeTo(com.google.protobuf.CodedOutputStream output)
6784                         throws java.io.IOException {
6785       getSerializedSize();
6786       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6787         output.writeEnum(1, type_.getNumber());
6788       }
6789       if (((bitField0_ & 0x00000002) == 0x00000002)) {
6790         output.writeBytes(2, getNameBytes());
6791       }
6792       if (((bitField0_ & 0x00000004) == 0x00000004)) {
6793         output.writeMessage(3, value_);
6794       }
6795       if (((bitField0_ & 0x00000008) == 0x00000008)) {
6796         output.writeMessage(4, event_);
6797       }
6798       getUnknownFields().writeTo(output);
6799     }
6800
6801     private int memoizedSerializedSize = -1;
6802     public int getSerializedSize() {
6803       int size = memoizedSerializedSize;
6804       if (size != -1) return size;
6805
6806       size = 0;
6807       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6808         size += com.google.protobuf.CodedOutputStream
6809           .computeEnumSize(1, type_.getNumber());
6810       }
6811       if (((bitField0_ & 0x00000002) == 0x00000002)) {
6812         size += com.google.protobuf.CodedOutputStream
6813           .computeBytesSize(2, getNameBytes());
6814       }
6815       if (((bitField0_ & 0x00000004) == 0x00000004)) {
6816         size += com.google.protobuf.CodedOutputStream
6817           .computeMessageSize(3, value_);
6818       }
6819       if (((bitField0_ & 0x00000008) == 0x00000008)) {
6820         size += com.google.protobuf.CodedOutputStream
6821           .computeMessageSize(4, event_);
6822       }
6823       size += getUnknownFields().getSerializedSize();
6824       memoizedSerializedSize = size;
6825       return size;
6826     }
6827
6828     private static final long serialVersionUID = 0L;
6829     @java.lang.Override
6830     protected java.lang.Object writeReplace()
6831         throws java.io.ObjectStreamException {
6832       return super.writeReplace();
6833     }
6834
6835     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
6836         com.google.protobuf.ByteString data)
6837         throws com.google.protobuf.InvalidProtocolBufferException {
6838       return PARSER.parseFrom(data);
6839     }
6840     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
6841         com.google.protobuf.ByteString data,
6842         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6843         throws com.google.protobuf.InvalidProtocolBufferException {
6844       return PARSER.parseFrom(data, extensionRegistry);
6845     }
6846     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(byte[] data)
6847         throws com.google.protobuf.InvalidProtocolBufferException {
6848       return PARSER.parseFrom(data);
6849     }
6850     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
6851         byte[] data,
6852         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6853         throws com.google.protobuf.InvalidProtocolBufferException {
6854       return PARSER.parseFrom(data, extensionRegistry);
6855     }
6856     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(java.io.InputStream input)
6857         throws java.io.IOException {
6858       return PARSER.parseFrom(input);
6859     }
6860     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
6861         java.io.InputStream input,
6862         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6863         throws java.io.IOException {
6864       return PARSER.parseFrom(input, extensionRegistry);
6865     }
6866     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(java.io.InputStream input)
6867         throws java.io.IOException {
6868       return PARSER.parseDelimitedFrom(input);
6869     }
6870     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(
6871         java.io.InputStream input,
6872         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6873         throws java.io.IOException {
6874       return PARSER.parseDelimitedFrom(input, extensionRegistry);
6875     }
6876     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
6877         com.google.protobuf.CodedInputStream input)
6878         throws java.io.IOException {
6879       return PARSER.parseFrom(input);
6880     }
6881     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
6882         com.google.protobuf.CodedInputStream input,
6883         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6884         throws java.io.IOException {
6885       return PARSER.parseFrom(input, extensionRegistry);
6886     }
6887
6888     public static Builder newBuilder() { return Builder.create(); }
6889     public Builder newBuilderForType() { return newBuilder(); }
6890     public static Builder newBuilder(com.openxc.BinaryMessages.TranslatedMessage prototype) {
6891       return newBuilder().mergeFrom(prototype);
6892     }
6893     public Builder toBuilder() { return newBuilder(this); }
6894
6895     @java.lang.Override
6896     protected Builder newBuilderForType(
6897         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6898       Builder builder = new Builder(parent);
6899       return builder;
6900     }
6901     /**
6902      * Protobuf type {@code openxc.TranslatedMessage}
6903      */
6904     public static final class Builder extends
6905         com.google.protobuf.GeneratedMessage.Builder<Builder>
6906        implements com.openxc.BinaryMessages.TranslatedMessageOrBuilder {
6907       public static final com.google.protobuf.Descriptors.Descriptor
6908           getDescriptor() {
6909         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
6910       }
6911
6912       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6913           internalGetFieldAccessorTable() {
6914         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
6915             .ensureFieldAccessorsInitialized(
6916                 com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
6917       }
6918
6919       // Construct using com.openxc.BinaryMessages.TranslatedMessage.newBuilder()
6920       private Builder() {
6921         maybeForceBuilderInitialization();
6922       }
6923
6924       private Builder(
6925           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6926         super(parent);
6927         maybeForceBuilderInitialization();
6928       }
6929       private void maybeForceBuilderInitialization() {
6930         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
6931           getValueFieldBuilder();
6932           getEventFieldBuilder();
6933         }
6934       }
6935       private static Builder create() {
6936         return new Builder();
6937       }
6938
6939       public Builder clear() {
6940         super.clear();
6941         type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
6942         bitField0_ = (bitField0_ & ~0x00000001);
6943         name_ = "";
6944         bitField0_ = (bitField0_ & ~0x00000002);
6945         if (valueBuilder_ == null) {
6946           value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
6947         } else {
6948           valueBuilder_.clear();
6949         }
6950         bitField0_ = (bitField0_ & ~0x00000004);
6951         if (eventBuilder_ == null) {
6952           event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
6953         } else {
6954           eventBuilder_.clear();
6955         }
6956         bitField0_ = (bitField0_ & ~0x00000008);
6957         return this;
6958       }
6959
6960       public Builder clone() {
6961         return create().mergeFrom(buildPartial());
6962       }
6963
6964       public com.google.protobuf.Descriptors.Descriptor
6965           getDescriptorForType() {
6966         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
6967       }
6968
6969       public com.openxc.BinaryMessages.TranslatedMessage getDefaultInstanceForType() {
6970         return com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
6971       }
6972
6973       public com.openxc.BinaryMessages.TranslatedMessage build() {
6974         com.openxc.BinaryMessages.TranslatedMessage result = buildPartial();
6975         if (!result.isInitialized()) {
6976           throw newUninitializedMessageException(result);
6977         }
6978         return result;
6979       }
6980
6981       public com.openxc.BinaryMessages.TranslatedMessage buildPartial() {
6982         com.openxc.BinaryMessages.TranslatedMessage result = new com.openxc.BinaryMessages.TranslatedMessage(this);
6983         int from_bitField0_ = bitField0_;
6984         int to_bitField0_ = 0;
6985         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
6986           to_bitField0_ |= 0x00000001;
6987         }
6988         result.type_ = type_;
6989         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
6990           to_bitField0_ |= 0x00000002;
6991         }
6992         result.name_ = name_;
6993         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
6994           to_bitField0_ |= 0x00000004;
6995         }
6996         if (valueBuilder_ == null) {
6997           result.value_ = value_;
6998         } else {
6999           result.value_ = valueBuilder_.build();
7000         }
7001         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
7002           to_bitField0_ |= 0x00000008;
7003         }
7004         if (eventBuilder_ == null) {
7005           result.event_ = event_;
7006         } else {
7007           result.event_ = eventBuilder_.build();
7008         }
7009         result.bitField0_ = to_bitField0_;
7010         onBuilt();
7011         return result;
7012       }
7013
7014       public Builder mergeFrom(com.google.protobuf.Message other) {
7015         if (other instanceof com.openxc.BinaryMessages.TranslatedMessage) {
7016           return mergeFrom((com.openxc.BinaryMessages.TranslatedMessage)other);
7017         } else {
7018           super.mergeFrom(other);
7019           return this;
7020         }
7021       }
7022
7023       public Builder mergeFrom(com.openxc.BinaryMessages.TranslatedMessage other) {
7024         if (other == com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance()) return this;
7025         if (other.hasType()) {
7026           setType(other.getType());
7027         }
7028         if (other.hasName()) {
7029           bitField0_ |= 0x00000002;
7030           name_ = other.name_;
7031           onChanged();
7032         }
7033         if (other.hasValue()) {
7034           mergeValue(other.getValue());
7035         }
7036         if (other.hasEvent()) {
7037           mergeEvent(other.getEvent());
7038         }
7039         this.mergeUnknownFields(other.getUnknownFields());
7040         return this;
7041       }
7042
7043       public final boolean isInitialized() {
7044         return true;
7045       }
7046
7047       public Builder mergeFrom(
7048           com.google.protobuf.CodedInputStream input,
7049           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7050           throws java.io.IOException {
7051         com.openxc.BinaryMessages.TranslatedMessage parsedMessage = null;
7052         try {
7053           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
7054         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
7055           parsedMessage = (com.openxc.BinaryMessages.TranslatedMessage) e.getUnfinishedMessage();
7056           throw e;
7057         } finally {
7058           if (parsedMessage != null) {
7059             mergeFrom(parsedMessage);
7060           }
7061         }
7062         return this;
7063       }
7064       private int bitField0_;
7065
7066       // optional .openxc.TranslatedMessage.Type type = 1;
7067       private com.openxc.BinaryMessages.TranslatedMessage.Type type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
7068       /**
7069        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
7070        */
7071       public boolean hasType() {
7072         return ((bitField0_ & 0x00000001) == 0x00000001);
7073       }
7074       /**
7075        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
7076        */
7077       public com.openxc.BinaryMessages.TranslatedMessage.Type getType() {
7078         return type_;
7079       }
7080       /**
7081        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
7082        */
7083       public Builder setType(com.openxc.BinaryMessages.TranslatedMessage.Type value) {
7084         if (value == null) {
7085           throw new NullPointerException();
7086         }
7087         bitField0_ |= 0x00000001;
7088         type_ = value;
7089         onChanged();
7090         return this;
7091       }
7092       /**
7093        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
7094        */
7095       public Builder clearType() {
7096         bitField0_ = (bitField0_ & ~0x00000001);
7097         type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
7098         onChanged();
7099         return this;
7100       }
7101
7102       // optional string name = 2;
7103       private java.lang.Object name_ = "";
7104       /**
7105        * <code>optional string name = 2;</code>
7106        */
7107       public boolean hasName() {
7108         return ((bitField0_ & 0x00000002) == 0x00000002);
7109       }
7110       /**
7111        * <code>optional string name = 2;</code>
7112        */
7113       public java.lang.String getName() {
7114         java.lang.Object ref = name_;
7115         if (!(ref instanceof java.lang.String)) {
7116           java.lang.String s = ((com.google.protobuf.ByteString) ref)
7117               .toStringUtf8();
7118           name_ = s;
7119           return s;
7120         } else {
7121           return (java.lang.String) ref;
7122         }
7123       }
7124       /**
7125        * <code>optional string name = 2;</code>
7126        */
7127       public com.google.protobuf.ByteString
7128           getNameBytes() {
7129         java.lang.Object ref = name_;
7130         if (ref instanceof String) {
7131           com.google.protobuf.ByteString b = 
7132               com.google.protobuf.ByteString.copyFromUtf8(
7133                   (java.lang.String) ref);
7134           name_ = b;
7135           return b;
7136         } else {
7137           return (com.google.protobuf.ByteString) ref;
7138         }
7139       }
7140       /**
7141        * <code>optional string name = 2;</code>
7142        */
7143       public Builder setName(
7144           java.lang.String value) {
7145         if (value == null) {
7146     throw new NullPointerException();
7147   }
7148   bitField0_ |= 0x00000002;
7149         name_ = value;
7150         onChanged();
7151         return this;
7152       }
7153       /**
7154        * <code>optional string name = 2;</code>
7155        */
7156       public Builder clearName() {
7157         bitField0_ = (bitField0_ & ~0x00000002);
7158         name_ = getDefaultInstance().getName();
7159         onChanged();
7160         return this;
7161       }
7162       /**
7163        * <code>optional string name = 2;</code>
7164        */
7165       public Builder setNameBytes(
7166           com.google.protobuf.ByteString value) {
7167         if (value == null) {
7168     throw new NullPointerException();
7169   }
7170   bitField0_ |= 0x00000002;
7171         name_ = value;
7172         onChanged();
7173         return this;
7174       }
7175
7176       // optional .openxc.DynamicField value = 3;
7177       private com.openxc.BinaryMessages.DynamicField value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7178       private com.google.protobuf.SingleFieldBuilder<
7179           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder> valueBuilder_;
7180       /**
7181        * <code>optional .openxc.DynamicField value = 3;</code>
7182        */
7183       public boolean hasValue() {
7184         return ((bitField0_ & 0x00000004) == 0x00000004);
7185       }
7186       /**
7187        * <code>optional .openxc.DynamicField value = 3;</code>
7188        */
7189       public com.openxc.BinaryMessages.DynamicField getValue() {
7190         if (valueBuilder_ == null) {
7191           return value_;
7192         } else {
7193           return valueBuilder_.getMessage();
7194         }
7195       }
7196       /**
7197        * <code>optional .openxc.DynamicField value = 3;</code>
7198        */
7199       public Builder setValue(com.openxc.BinaryMessages.DynamicField value) {
7200         if (valueBuilder_ == null) {
7201           if (value == null) {
7202             throw new NullPointerException();
7203           }
7204           value_ = value;
7205           onChanged();
7206         } else {
7207           valueBuilder_.setMessage(value);
7208         }
7209         bitField0_ |= 0x00000004;
7210         return this;
7211       }
7212       /**
7213        * <code>optional .openxc.DynamicField value = 3;</code>
7214        */
7215       public Builder setValue(
7216           com.openxc.BinaryMessages.DynamicField.Builder builderForValue) {
7217         if (valueBuilder_ == null) {
7218           value_ = builderForValue.build();
7219           onChanged();
7220         } else {
7221           valueBuilder_.setMessage(builderForValue.build());
7222         }
7223         bitField0_ |= 0x00000004;
7224         return this;
7225       }
7226       /**
7227        * <code>optional .openxc.DynamicField value = 3;</code>
7228        */
7229       public Builder mergeValue(com.openxc.BinaryMessages.DynamicField value) {
7230         if (valueBuilder_ == null) {
7231           if (((bitField0_ & 0x00000004) == 0x00000004) &&
7232               value_ != com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) {
7233             value_ =
7234               com.openxc.BinaryMessages.DynamicField.newBuilder(value_).mergeFrom(value).buildPartial();
7235           } else {
7236             value_ = value;
7237           }
7238           onChanged();
7239         } else {
7240           valueBuilder_.mergeFrom(value);
7241         }
7242         bitField0_ |= 0x00000004;
7243         return this;
7244       }
7245       /**
7246        * <code>optional .openxc.DynamicField value = 3;</code>
7247        */
7248       public Builder clearValue() {
7249         if (valueBuilder_ == null) {
7250           value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7251           onChanged();
7252         } else {
7253           valueBuilder_.clear();
7254         }
7255         bitField0_ = (bitField0_ & ~0x00000004);
7256         return this;
7257       }
7258       /**
7259        * <code>optional .openxc.DynamicField value = 3;</code>
7260        */
7261       public com.openxc.BinaryMessages.DynamicField.Builder getValueBuilder() {
7262         bitField0_ |= 0x00000004;
7263         onChanged();
7264         return getValueFieldBuilder().getBuilder();
7265       }
7266       /**
7267        * <code>optional .openxc.DynamicField value = 3;</code>
7268        */
7269       public com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder() {
7270         if (valueBuilder_ != null) {
7271           return valueBuilder_.getMessageOrBuilder();
7272         } else {
7273           return value_;
7274         }
7275       }
7276       /**
7277        * <code>optional .openxc.DynamicField value = 3;</code>
7278        */
7279       private com.google.protobuf.SingleFieldBuilder<
7280           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder> 
7281           getValueFieldBuilder() {
7282         if (valueBuilder_ == null) {
7283           valueBuilder_ = new com.google.protobuf.SingleFieldBuilder<
7284               com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>(
7285                   value_,
7286                   getParentForChildren(),
7287                   isClean());
7288           value_ = null;
7289         }
7290         return valueBuilder_;
7291       }
7292
7293       // optional .openxc.DynamicField event = 4;
7294       private com.openxc.BinaryMessages.DynamicField event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7295       private com.google.protobuf.SingleFieldBuilder<
7296           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder> eventBuilder_;
7297       /**
7298        * <code>optional .openxc.DynamicField event = 4;</code>
7299        */
7300       public boolean hasEvent() {
7301         return ((bitField0_ & 0x00000008) == 0x00000008);
7302       }
7303       /**
7304        * <code>optional .openxc.DynamicField event = 4;</code>
7305        */
7306       public com.openxc.BinaryMessages.DynamicField getEvent() {
7307         if (eventBuilder_ == null) {
7308           return event_;
7309         } else {
7310           return eventBuilder_.getMessage();
7311         }
7312       }
7313       /**
7314        * <code>optional .openxc.DynamicField event = 4;</code>
7315        */
7316       public Builder setEvent(com.openxc.BinaryMessages.DynamicField value) {
7317         if (eventBuilder_ == null) {
7318           if (value == null) {
7319             throw new NullPointerException();
7320           }
7321           event_ = value;
7322           onChanged();
7323         } else {
7324           eventBuilder_.setMessage(value);
7325         }
7326         bitField0_ |= 0x00000008;
7327         return this;
7328       }
7329       /**
7330        * <code>optional .openxc.DynamicField event = 4;</code>
7331        */
7332       public Builder setEvent(
7333           com.openxc.BinaryMessages.DynamicField.Builder builderForValue) {
7334         if (eventBuilder_ == null) {
7335           event_ = builderForValue.build();
7336           onChanged();
7337         } else {
7338           eventBuilder_.setMessage(builderForValue.build());
7339         }
7340         bitField0_ |= 0x00000008;
7341         return this;
7342       }
7343       /**
7344        * <code>optional .openxc.DynamicField event = 4;</code>
7345        */
7346       public Builder mergeEvent(com.openxc.BinaryMessages.DynamicField value) {
7347         if (eventBuilder_ == null) {
7348           if (((bitField0_ & 0x00000008) == 0x00000008) &&
7349               event_ != com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) {
7350             event_ =
7351               com.openxc.BinaryMessages.DynamicField.newBuilder(event_).mergeFrom(value).buildPartial();
7352           } else {
7353             event_ = value;
7354           }
7355           onChanged();
7356         } else {
7357           eventBuilder_.mergeFrom(value);
7358         }
7359         bitField0_ |= 0x00000008;
7360         return this;
7361       }
7362       /**
7363        * <code>optional .openxc.DynamicField event = 4;</code>
7364        */
7365       public Builder clearEvent() {
7366         if (eventBuilder_ == null) {
7367           event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7368           onChanged();
7369         } else {
7370           eventBuilder_.clear();
7371         }
7372         bitField0_ = (bitField0_ & ~0x00000008);
7373         return this;
7374       }
7375       /**
7376        * <code>optional .openxc.DynamicField event = 4;</code>
7377        */
7378       public com.openxc.BinaryMessages.DynamicField.Builder getEventBuilder() {
7379         bitField0_ |= 0x00000008;
7380         onChanged();
7381         return getEventFieldBuilder().getBuilder();
7382       }
7383       /**
7384        * <code>optional .openxc.DynamicField event = 4;</code>
7385        */
7386       public com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder() {
7387         if (eventBuilder_ != null) {
7388           return eventBuilder_.getMessageOrBuilder();
7389         } else {
7390           return event_;
7391         }
7392       }
7393       /**
7394        * <code>optional .openxc.DynamicField event = 4;</code>
7395        */
7396       private com.google.protobuf.SingleFieldBuilder<
7397           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder> 
7398           getEventFieldBuilder() {
7399         if (eventBuilder_ == null) {
7400           eventBuilder_ = new com.google.protobuf.SingleFieldBuilder<
7401               com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>(
7402                   event_,
7403                   getParentForChildren(),
7404                   isClean());
7405           event_ = null;
7406         }
7407         return eventBuilder_;
7408       }
7409
7410       // @@protoc_insertion_point(builder_scope:openxc.TranslatedMessage)
7411     }
7412
7413     static {
7414       defaultInstance = new TranslatedMessage(true);
7415       defaultInstance.initFields();
7416     }
7417
7418     // @@protoc_insertion_point(class_scope:openxc.TranslatedMessage)
7419   }
7420
7421   private static com.google.protobuf.Descriptors.Descriptor
7422     internal_static_openxc_VehicleMessage_descriptor;
7423   private static
7424     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7425       internal_static_openxc_VehicleMessage_fieldAccessorTable;
7426   private static com.google.protobuf.Descriptors.Descriptor
7427     internal_static_openxc_RawMessage_descriptor;
7428   private static
7429     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7430       internal_static_openxc_RawMessage_fieldAccessorTable;
7431   private static com.google.protobuf.Descriptors.Descriptor
7432     internal_static_openxc_ControlCommand_descriptor;
7433   private static
7434     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7435       internal_static_openxc_ControlCommand_fieldAccessorTable;
7436   private static com.google.protobuf.Descriptors.Descriptor
7437     internal_static_openxc_CommandResponse_descriptor;
7438   private static
7439     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7440       internal_static_openxc_CommandResponse_fieldAccessorTable;
7441   private static com.google.protobuf.Descriptors.Descriptor
7442     internal_static_openxc_DiagnosticRequest_descriptor;
7443   private static
7444     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7445       internal_static_openxc_DiagnosticRequest_fieldAccessorTable;
7446   private static com.google.protobuf.Descriptors.Descriptor
7447     internal_static_openxc_DiagnosticResponse_descriptor;
7448   private static
7449     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7450       internal_static_openxc_DiagnosticResponse_fieldAccessorTable;
7451   private static com.google.protobuf.Descriptors.Descriptor
7452     internal_static_openxc_DynamicField_descriptor;
7453   private static
7454     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7455       internal_static_openxc_DynamicField_fieldAccessorTable;
7456   private static com.google.protobuf.Descriptors.Descriptor
7457     internal_static_openxc_TranslatedMessage_descriptor;
7458   private static
7459     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7460       internal_static_openxc_TranslatedMessage_fieldAccessorTable;
7461
7462   public static com.google.protobuf.Descriptors.FileDescriptor
7463       getDescriptor() {
7464     return descriptor;
7465   }
7466   private static com.google.protobuf.Descriptors.FileDescriptor
7467       descriptor;
7468   static {
7469     java.lang.String[] descriptorData = {
7470       "\n\014openxc.proto\022\006openxc\"\224\003\n\016VehicleMessag" +
7471       "e\022)\n\004type\030\001 \001(\0162\033.openxc.VehicleMessage." +
7472       "Type\022\'\n\013raw_message\030\002 \001(\0132\022.openxc.RawMe" +
7473       "ssage\0225\n\022translated_message\030\003 \001(\0132\031.open" +
7474       "xc.TranslatedMessage\0227\n\023diagnostic_respo" +
7475       "nse\030\004 \001(\0132\032.openxc.DiagnosticResponse\022/\n" +
7476       "\017control_command\030\005 \001(\0132\026.openxc.ControlC" +
7477       "ommand\0221\n\020command_response\030\006 \001(\0132\027.openx" +
7478       "c.CommandResponse\"Z\n\004Type\022\007\n\003RAW\020\001\022\016\n\nTR" +
7479       "ANSLATED\020\002\022\016\n\nDIAGNOSTIC\020\003\022\023\n\017CONTROL_CO",
7480       "MMAND\020\004\022\024\n\020COMMAND_RESPONSE\020\005\";\n\nRawMess" +
7481       "age\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessage_id\030\002 \001(\r\022\014\n\004" +
7482       "data\030\003 \001(\014\"\246\001\n\016ControlCommand\022)\n\004type\030\001 " +
7483       "\001(\0162\033.openxc.ControlCommand.Type\0225\n\022diag" +
7484       "nostic_request\030\002 \001(\0132\031.openxc.Diagnostic" +
7485       "Request\"2\n\004Type\022\013\n\007VERSION\020\001\022\r\n\tDEVICE_I" +
7486       "D\020\002\022\016\n\nDIAGNOSTIC\020\003\"M\n\017CommandResponse\022)" +
7487       "\n\004type\030\001 \001(\0162\033.openxc.ControlCommand.Typ" +
7488       "e\022\017\n\007message\030\002 \001(\t\"\275\001\n\021DiagnosticRequest" +
7489       "\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessage_id\030\002 \001(\r\022\014\n\004mod",
7490       "e\030\003 \001(\r\022\013\n\003pid\030\004 \001(\r\022\017\n\007payload\030\005 \001(\014\022\032\n" +
7491       "\022multiple_responses\030\006 \001(\010\022\016\n\006factor\030\007 \001(" +
7492       "\001\022\016\n\006offset\030\010 \001(\001\022\021\n\tfrequency\030\t \001(\001\022\014\n\004" +
7493       "name\030\n \001(\t\"\241\001\n\022DiagnosticResponse\022\013\n\003bus" +
7494       "\030\001 \001(\005\022\022\n\nmessage_id\030\002 \001(\r\022\014\n\004mode\030\003 \001(\r" +
7495       "\022\013\n\003pid\030\004 \001(\r\022\017\n\007success\030\005 \001(\010\022\036\n\026negati" +
7496       "ve_response_code\030\006 \001(\r\022\017\n\007payload\030\007 \001(\014\022" +
7497       "\r\n\005value\030\010 \001(\001\"\242\001\n\014DynamicField\022\'\n\004type\030" +
7498       "\001 \001(\0162\031.openxc.DynamicField.Type\022\024\n\014stri" +
7499       "ng_value\030\002 \001(\t\022\025\n\rnumeric_value\030\003 \001(\001\022\025\n",
7500       "\rboolean_value\030\004 \001(\010\"%\n\004Type\022\n\n\006STRING\020\001" +
7501       "\022\007\n\003NUM\020\002\022\010\n\004BOOL\020\003\"\367\001\n\021TranslatedMessag" +
7502       "e\022,\n\004type\030\001 \001(\0162\036.openxc.TranslatedMessa" +
7503       "ge.Type\022\014\n\004name\030\002 \001(\t\022#\n\005value\030\003 \001(\0132\024.o" +
7504       "penxc.DynamicField\022#\n\005event\030\004 \001(\0132\024.open" +
7505       "xc.DynamicField\"\\\n\004Type\022\n\n\006STRING\020\001\022\007\n\003N" +
7506       "UM\020\002\022\010\n\004BOOL\020\003\022\022\n\016EVENTED_STRING\020\004\022\017\n\013EV" +
7507       "ENTED_NUM\020\005\022\020\n\014EVENTED_BOOL\020\006B\034\n\ncom.ope" +
7508       "nxcB\016BinaryMessages"
7509     };
7510     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
7511       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
7512         public com.google.protobuf.ExtensionRegistry assignDescriptors(
7513             com.google.protobuf.Descriptors.FileDescriptor root) {
7514           descriptor = root;
7515           internal_static_openxc_VehicleMessage_descriptor =
7516             getDescriptor().getMessageTypes().get(0);
7517           internal_static_openxc_VehicleMessage_fieldAccessorTable = new
7518             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7519               internal_static_openxc_VehicleMessage_descriptor,
7520               new java.lang.String[] { "Type", "RawMessage", "TranslatedMessage", "DiagnosticResponse", "ControlCommand", "CommandResponse", });
7521           internal_static_openxc_RawMessage_descriptor =
7522             getDescriptor().getMessageTypes().get(1);
7523           internal_static_openxc_RawMessage_fieldAccessorTable = new
7524             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7525               internal_static_openxc_RawMessage_descriptor,
7526               new java.lang.String[] { "Bus", "MessageId", "Data", });
7527           internal_static_openxc_ControlCommand_descriptor =
7528             getDescriptor().getMessageTypes().get(2);
7529           internal_static_openxc_ControlCommand_fieldAccessorTable = new
7530             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7531               internal_static_openxc_ControlCommand_descriptor,
7532               new java.lang.String[] { "Type", "DiagnosticRequest", });
7533           internal_static_openxc_CommandResponse_descriptor =
7534             getDescriptor().getMessageTypes().get(3);
7535           internal_static_openxc_CommandResponse_fieldAccessorTable = new
7536             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7537               internal_static_openxc_CommandResponse_descriptor,
7538               new java.lang.String[] { "Type", "Message", });
7539           internal_static_openxc_DiagnosticRequest_descriptor =
7540             getDescriptor().getMessageTypes().get(4);
7541           internal_static_openxc_DiagnosticRequest_fieldAccessorTable = new
7542             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7543               internal_static_openxc_DiagnosticRequest_descriptor,
7544               new java.lang.String[] { "Bus", "MessageId", "Mode", "Pid", "Payload", "MultipleResponses", "Factor", "Offset", "Frequency", "Name", });
7545           internal_static_openxc_DiagnosticResponse_descriptor =
7546             getDescriptor().getMessageTypes().get(5);
7547           internal_static_openxc_DiagnosticResponse_fieldAccessorTable = new
7548             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7549               internal_static_openxc_DiagnosticResponse_descriptor,
7550               new java.lang.String[] { "Bus", "MessageId", "Mode", "Pid", "Success", "NegativeResponseCode", "Payload", "Value", });
7551           internal_static_openxc_DynamicField_descriptor =
7552             getDescriptor().getMessageTypes().get(6);
7553           internal_static_openxc_DynamicField_fieldAccessorTable = new
7554             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7555               internal_static_openxc_DynamicField_descriptor,
7556               new java.lang.String[] { "Type", "StringValue", "NumericValue", "BooleanValue", });
7557           internal_static_openxc_TranslatedMessage_descriptor =
7558             getDescriptor().getMessageTypes().get(7);
7559           internal_static_openxc_TranslatedMessage_fieldAccessorTable = new
7560             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7561               internal_static_openxc_TranslatedMessage_descriptor,
7562               new java.lang.String[] { "Type", "Name", "Value", "Event", });
7563           return null;
7564         }
7565       };
7566     com.google.protobuf.Descriptors.FileDescriptor
7567       .internalBuildGeneratedFileFrom(descriptorData,
7568         new com.google.protobuf.Descriptors.FileDescriptor[] {
7569         }, assigner);
7570   }
7571
7572   // @@protoc_insertion_point(outer_class_scope)
7573 }