1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved.
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file or at
6 // https://developers.google.com/open-source/licenses/bsd
8 package com
.google
.protobuf
;
10 import static com
.google
.protobuf
.Internal
.checkNotNull
;
11 import static com
.google
.protobuf
.WireFormat
.WIRETYPE_LENGTH_DELIMITED
;
13 import java
.io
.IOException
;
14 import java
.util
.Arrays
;
15 import java
.util
.List
;
18 /** An adapter between the {@link Writer} interface and {@link CodedOutputStream}. */
21 final class CodedOutputStreamWriter
implements Writer
{
22 private final CodedOutputStream output
;
24 public static CodedOutputStreamWriter
forCodedOutput(CodedOutputStream output
) {
25 if (output
.wrapper
!= null) {
26 return output
.wrapper
;
28 return new CodedOutputStreamWriter(output
);
31 private CodedOutputStreamWriter(CodedOutputStream output
) {
32 this.output
= checkNotNull(output
, "output");
33 this.output
.wrapper
= this;
37 public FieldOrder
fieldOrder() {
38 return FieldOrder
.ASCENDING
;
41 public int getTotalBytesWritten() {
42 return output
.getTotalBytesWritten();
46 public void writeSFixed32(int fieldNumber
, int value
) throws IOException
{
47 output
.writeSFixed32(fieldNumber
, value
);
51 public void writeInt64(int fieldNumber
, long value
) throws IOException
{
52 output
.writeInt64(fieldNumber
, value
);
56 public void writeSFixed64(int fieldNumber
, long value
) throws IOException
{
57 output
.writeSFixed64(fieldNumber
, value
);
61 public void writeFloat(int fieldNumber
, float value
) throws IOException
{
62 output
.writeFloat(fieldNumber
, value
);
66 public void writeDouble(int fieldNumber
, double value
) throws IOException
{
67 output
.writeDouble(fieldNumber
, value
);
71 public void writeEnum(int fieldNumber
, int value
) throws IOException
{
72 output
.writeEnum(fieldNumber
, value
);
76 public void writeUInt64(int fieldNumber
, long value
) throws IOException
{
77 output
.writeUInt64(fieldNumber
, value
);
81 public void writeInt32(int fieldNumber
, int value
) throws IOException
{
82 output
.writeInt32(fieldNumber
, value
);
86 public void writeFixed64(int fieldNumber
, long value
) throws IOException
{
87 output
.writeFixed64(fieldNumber
, value
);
91 public void writeFixed32(int fieldNumber
, int value
) throws IOException
{
92 output
.writeFixed32(fieldNumber
, value
);
96 public void writeBool(int fieldNumber
, boolean value
) throws IOException
{
97 output
.writeBool(fieldNumber
, value
);
101 public void writeString(int fieldNumber
, String value
) throws IOException
{
102 output
.writeString(fieldNumber
, value
);
106 public void writeBytes(int fieldNumber
, ByteString value
) throws IOException
{
107 output
.writeBytes(fieldNumber
, value
);
111 public void writeUInt32(int fieldNumber
, int value
) throws IOException
{
112 output
.writeUInt32(fieldNumber
, value
);
116 public void writeSInt32(int fieldNumber
, int value
) throws IOException
{
117 output
.writeSInt32(fieldNumber
, value
);
121 public void writeSInt64(int fieldNumber
, long value
) throws IOException
{
122 output
.writeSInt64(fieldNumber
, value
);
126 public void writeMessage(int fieldNumber
, Object value
) throws IOException
{
127 output
.writeMessage(fieldNumber
, (MessageLite
) value
);
131 public void writeMessage(int fieldNumber
, Object value
, Schema schema
) throws IOException
{
132 output
.writeMessage(fieldNumber
, (MessageLite
) value
, schema
);
137 public void writeGroup(int fieldNumber
, Object value
) throws IOException
{
138 output
.writeGroup(fieldNumber
, (MessageLite
) value
);
142 public void writeGroup(int fieldNumber
, Object value
, Schema schema
) throws IOException
{
143 output
.writeGroup(fieldNumber
, (MessageLite
) value
, schema
);
148 public void writeStartGroup(int fieldNumber
) throws IOException
{
149 output
.writeTag(fieldNumber
, WireFormat
.WIRETYPE_START_GROUP
);
154 public void writeEndGroup(int fieldNumber
) throws IOException
{
155 output
.writeTag(fieldNumber
, WireFormat
.WIRETYPE_END_GROUP
);
159 public final void writeMessageSetItem(int fieldNumber
, Object value
) throws IOException
{
160 if (value
instanceof ByteString
) {
161 output
.writeRawMessageSetExtension(fieldNumber
, (ByteString
) value
);
163 output
.writeMessageSetExtension(fieldNumber
, (MessageLite
) value
);
168 public void writeInt32List(int fieldNumber
, List
<Integer
> value
, boolean packed
)
170 if (value
instanceof IntArrayList
) {
171 writeInt32ListInternal(fieldNumber
, (IntArrayList
) value
, packed
);
173 writeInt32ListInternal(fieldNumber
, value
, packed
);
177 private void writeInt32ListInternal(int fieldNumber
, IntArrayList value
, boolean packed
)
180 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
182 // Compute and write the length of the data.
184 for (int i
= 0; i
< value
.size(); ++i
) {
185 dataSize
+= CodedOutputStream
.computeInt32SizeNoTag(value
.getInt(i
));
187 output
.writeUInt32NoTag(dataSize
);
189 // Write the data itself, without any tags.
190 for (int i
= 0; i
< value
.size(); ++i
) {
191 output
.writeInt32NoTag(value
.getInt(i
));
194 for (int i
= 0; i
< value
.size(); ++i
) {
195 output
.writeInt32(fieldNumber
, value
.getInt(i
));
200 private void writeInt32ListInternal(int fieldNumber
, List
<Integer
> value
, boolean packed
)
203 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
205 // Compute and write the length of the data.
207 for (int i
= 0; i
< value
.size(); ++i
) {
208 dataSize
+= CodedOutputStream
.computeInt32SizeNoTag(value
.get(i
));
210 output
.writeUInt32NoTag(dataSize
);
212 // Write the data itself, without any tags.
213 for (int i
= 0; i
< value
.size(); ++i
) {
214 output
.writeInt32NoTag(value
.get(i
));
217 for (int i
= 0; i
< value
.size(); ++i
) {
218 output
.writeInt32(fieldNumber
, value
.get(i
));
224 public void writeFixed32List(int fieldNumber
, List
<Integer
> value
, boolean packed
)
226 if (value
instanceof IntArrayList
) {
227 writeFixed32ListInternal(fieldNumber
, (IntArrayList
) value
, packed
);
229 writeFixed32ListInternal(fieldNumber
, value
, packed
);
233 private void writeFixed32ListInternal(int fieldNumber
, IntArrayList value
, boolean packed
)
236 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
238 // Compute and write the length of the data.
240 for (int i
= 0; i
< value
.size(); ++i
) {
241 dataSize
+= CodedOutputStream
.computeFixed32SizeNoTag(value
.getInt(i
));
243 output
.writeUInt32NoTag(dataSize
);
245 // Write the data itself, without any tags.
246 for (int i
= 0; i
< value
.size(); ++i
) {
247 output
.writeFixed32NoTag(value
.getInt(i
));
250 for (int i
= 0; i
< value
.size(); ++i
) {
251 output
.writeFixed32(fieldNumber
, value
.getInt(i
));
256 private void writeFixed32ListInternal(int fieldNumber
, List
<Integer
> value
, boolean packed
)
259 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
261 // Compute and write the length of the data.
263 for (int i
= 0; i
< value
.size(); ++i
) {
264 dataSize
+= CodedOutputStream
.computeFixed32SizeNoTag(value
.get(i
));
266 output
.writeUInt32NoTag(dataSize
);
268 // Write the data itself, without any tags.
269 for (int i
= 0; i
< value
.size(); ++i
) {
270 output
.writeFixed32NoTag(value
.get(i
));
273 for (int i
= 0; i
< value
.size(); ++i
) {
274 output
.writeFixed32(fieldNumber
, value
.get(i
));
280 public void writeInt64List(int fieldNumber
, List
<Long
> value
, boolean packed
) throws IOException
{
281 if (value
instanceof LongArrayList
) {
282 writeInt64ListInternal(fieldNumber
, (LongArrayList
) value
, packed
);
284 writeInt64ListInternal(fieldNumber
, value
, packed
);
288 private void writeInt64ListInternal(int fieldNumber
, LongArrayList value
, boolean packed
)
291 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
293 // Compute and write the length of the data.
295 for (int i
= 0; i
< value
.size(); ++i
) {
296 dataSize
+= CodedOutputStream
.computeInt64SizeNoTag(value
.getLong(i
));
298 output
.writeUInt32NoTag(dataSize
);
300 // Write the data itself, without any tags.
301 for (int i
= 0; i
< value
.size(); ++i
) {
302 output
.writeInt64NoTag(value
.getLong(i
));
305 for (int i
= 0; i
< value
.size(); ++i
) {
306 output
.writeInt64(fieldNumber
, value
.getLong(i
));
311 private void writeInt64ListInternal(int fieldNumber
, List
<Long
> value
, boolean packed
)
314 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
316 // Compute and write the length of the data.
318 for (int i
= 0; i
< value
.size(); ++i
) {
319 dataSize
+= CodedOutputStream
.computeInt64SizeNoTag(value
.get(i
));
321 output
.writeUInt32NoTag(dataSize
);
323 // Write the data itself, without any tags.
324 for (int i
= 0; i
< value
.size(); ++i
) {
325 output
.writeInt64NoTag(value
.get(i
));
328 for (int i
= 0; i
< value
.size(); ++i
) {
329 output
.writeInt64(fieldNumber
, value
.get(i
));
334 public void writeUInt64List(int fieldNumber
, List
<Long
> value
, boolean packed
)
336 if (value
instanceof LongArrayList
) {
337 writeUInt64ListInternal(fieldNumber
, (LongArrayList
) value
, packed
);
339 writeUInt64ListInternal(fieldNumber
, value
, packed
);
343 private void writeUInt64ListInternal(int fieldNumber
, LongArrayList value
, boolean packed
)
346 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
348 // Compute and write the length of the data.
350 for (int i
= 0; i
< value
.size(); ++i
) {
351 dataSize
+= CodedOutputStream
.computeUInt64SizeNoTag(value
.getLong(i
));
353 output
.writeUInt32NoTag(dataSize
);
355 // Write the data itself, without any tags.
356 for (int i
= 0; i
< value
.size(); ++i
) {
357 output
.writeUInt64NoTag(value
.getLong(i
));
360 for (int i
= 0; i
< value
.size(); ++i
) {
361 output
.writeUInt64(fieldNumber
, value
.getLong(i
));
366 private void writeUInt64ListInternal(int fieldNumber
, List
<Long
> value
, boolean packed
)
369 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
371 // Compute and write the length of the data.
373 for (int i
= 0; i
< value
.size(); ++i
) {
374 dataSize
+= CodedOutputStream
.computeUInt64SizeNoTag(value
.get(i
));
376 output
.writeUInt32NoTag(dataSize
);
378 // Write the data itself, without any tags.
379 for (int i
= 0; i
< value
.size(); ++i
) {
380 output
.writeUInt64NoTag(value
.get(i
));
383 for (int i
= 0; i
< value
.size(); ++i
) {
384 output
.writeUInt64(fieldNumber
, value
.get(i
));
390 public void writeFixed64List(int fieldNumber
, List
<Long
> value
, boolean packed
)
392 if (value
instanceof LongArrayList
) {
393 writeFixed64ListInternal(fieldNumber
, (LongArrayList
) value
, packed
);
395 writeFixed64ListInternal(fieldNumber
, value
, packed
);
399 private void writeFixed64ListInternal(int fieldNumber
, LongArrayList value
, boolean packed
)
402 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
404 // Compute and write the length of the data.
406 for (int i
= 0; i
< value
.size(); ++i
) {
407 dataSize
+= CodedOutputStream
.computeFixed64SizeNoTag(value
.getLong(i
));
409 output
.writeUInt32NoTag(dataSize
);
411 // Write the data itself, without any tags.
412 for (int i
= 0; i
< value
.size(); ++i
) {
413 output
.writeFixed64NoTag(value
.getLong(i
));
416 for (int i
= 0; i
< value
.size(); ++i
) {
417 output
.writeFixed64(fieldNumber
, value
.getLong(i
));
422 private void writeFixed64ListInternal(int fieldNumber
, List
<Long
> value
, boolean packed
)
425 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
427 // Compute and write the length of the data.
429 for (int i
= 0; i
< value
.size(); ++i
) {
430 dataSize
+= CodedOutputStream
.computeFixed64SizeNoTag(value
.get(i
));
432 output
.writeUInt32NoTag(dataSize
);
434 // Write the data itself, without any tags.
435 for (int i
= 0; i
< value
.size(); ++i
) {
436 output
.writeFixed64NoTag(value
.get(i
));
439 for (int i
= 0; i
< value
.size(); ++i
) {
440 output
.writeFixed64(fieldNumber
, value
.get(i
));
446 public void writeFloatList(int fieldNumber
, List
<Float
> value
, boolean packed
)
448 if (value
instanceof FloatArrayList
) {
449 writeFloatListInternal(fieldNumber
, (FloatArrayList
) value
, packed
);
451 writeFloatListInternal(fieldNumber
, value
, packed
);
455 private void writeFloatListInternal(int fieldNumber
, FloatArrayList value
, boolean packed
)
458 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
460 // Compute and write the length of the data.
462 for (int i
= 0; i
< value
.size(); ++i
) {
463 dataSize
+= CodedOutputStream
.computeFloatSizeNoTag(value
.getFloat(i
));
465 output
.writeUInt32NoTag(dataSize
);
467 // Write the data itself, without any tags.
468 for (int i
= 0; i
< value
.size(); ++i
) {
469 output
.writeFloatNoTag(value
.getFloat(i
));
472 for (int i
= 0; i
< value
.size(); ++i
) {
473 output
.writeFloat(fieldNumber
, value
.getFloat(i
));
478 private void writeFloatListInternal(int fieldNumber
, List
<Float
> value
, boolean packed
)
481 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
483 // Compute and write the length of the data.
485 for (int i
= 0; i
< value
.size(); ++i
) {
486 dataSize
+= CodedOutputStream
.computeFloatSizeNoTag(value
.get(i
));
488 output
.writeUInt32NoTag(dataSize
);
490 // Write the data itself, without any tags.
491 for (int i
= 0; i
< value
.size(); ++i
) {
492 output
.writeFloatNoTag(value
.get(i
));
495 for (int i
= 0; i
< value
.size(); ++i
) {
496 output
.writeFloat(fieldNumber
, value
.get(i
));
502 public void writeDoubleList(int fieldNumber
, List
<Double
> value
, boolean packed
)
504 if (value
instanceof DoubleArrayList
) {
505 writeDoubleListInternal(fieldNumber
, (DoubleArrayList
) value
, packed
);
507 writeDoubleListInternal(fieldNumber
, value
, packed
);
511 private void writeDoubleListInternal(int fieldNumber
, DoubleArrayList value
, boolean packed
)
514 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
516 // Compute and write the length of the data.
518 for (int i
= 0; i
< value
.size(); ++i
) {
519 dataSize
+= CodedOutputStream
.computeDoubleSizeNoTag(value
.getDouble(i
));
521 output
.writeUInt32NoTag(dataSize
);
523 // Write the data itself, without any tags.
524 for (int i
= 0; i
< value
.size(); ++i
) {
525 output
.writeDoubleNoTag(value
.getDouble(i
));
528 for (int i
= 0; i
< value
.size(); ++i
) {
529 output
.writeDouble(fieldNumber
, value
.getDouble(i
));
534 private void writeDoubleListInternal(int fieldNumber
, List
<Double
> value
, boolean packed
)
537 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
539 // Compute and write the length of the data.
541 for (int i
= 0; i
< value
.size(); ++i
) {
542 dataSize
+= CodedOutputStream
.computeDoubleSizeNoTag(value
.get(i
));
544 output
.writeUInt32NoTag(dataSize
);
546 // Write the data itself, without any tags.
547 for (int i
= 0; i
< value
.size(); ++i
) {
548 output
.writeDoubleNoTag(value
.get(i
));
551 for (int i
= 0; i
< value
.size(); ++i
) {
552 output
.writeDouble(fieldNumber
, value
.get(i
));
558 public void writeEnumList(int fieldNumber
, List
<Integer
> value
, boolean packed
)
561 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
563 // Compute and write the length of the data.
565 for (int i
= 0; i
< value
.size(); ++i
) {
566 dataSize
+= CodedOutputStream
.computeEnumSizeNoTag(value
.get(i
));
568 output
.writeUInt32NoTag(dataSize
);
570 // Write the data itself, without any tags.
571 for (int i
= 0; i
< value
.size(); ++i
) {
572 output
.writeEnumNoTag(value
.get(i
));
575 for (int i
= 0; i
< value
.size(); ++i
) {
576 output
.writeEnum(fieldNumber
, value
.get(i
));
582 public void writeBoolList(int fieldNumber
, List
<Boolean
> value
, boolean packed
)
584 if (value
instanceof BooleanArrayList
) {
585 writeBoolListInternal(fieldNumber
, (BooleanArrayList
) value
, packed
);
587 writeBoolListInternal(fieldNumber
, value
, packed
);
591 private void writeBoolListInternal(int fieldNumber
, BooleanArrayList value
, boolean packed
)
594 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
596 // Compute and write the length of the data.
598 for (int i
= 0; i
< value
.size(); ++i
) {
599 dataSize
+= CodedOutputStream
.computeBoolSizeNoTag(value
.getBoolean(i
));
601 output
.writeUInt32NoTag(dataSize
);
603 // Write the data itself, without any tags.
604 for (int i
= 0; i
< value
.size(); ++i
) {
605 output
.writeBoolNoTag(value
.getBoolean(i
));
608 for (int i
= 0; i
< value
.size(); ++i
) {
609 output
.writeBool(fieldNumber
, value
.getBoolean(i
));
614 private void writeBoolListInternal(int fieldNumber
, List
<Boolean
> value
, boolean packed
)
617 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
619 // Compute and write the length of the data.
621 for (int i
= 0; i
< value
.size(); ++i
) {
622 dataSize
+= CodedOutputStream
.computeBoolSizeNoTag(value
.get(i
));
624 output
.writeUInt32NoTag(dataSize
);
626 // Write the data itself, without any tags.
627 for (int i
= 0; i
< value
.size(); ++i
) {
628 output
.writeBoolNoTag(value
.get(i
));
631 for (int i
= 0; i
< value
.size(); ++i
) {
632 output
.writeBool(fieldNumber
, value
.get(i
));
638 public void writeStringList(int fieldNumber
, List
<String
> value
) throws IOException
{
639 if (value
instanceof LazyStringList
) {
640 final LazyStringList lazyList
= (LazyStringList
) value
;
641 for (int i
= 0; i
< value
.size(); ++i
) {
642 writeLazyString(fieldNumber
, lazyList
.getRaw(i
));
645 for (int i
= 0; i
< value
.size(); ++i
) {
646 output
.writeString(fieldNumber
, value
.get(i
));
651 private void writeLazyString(int fieldNumber
, Object value
) throws IOException
{
652 if (value
instanceof String
) {
653 output
.writeString(fieldNumber
, (String
) value
);
655 output
.writeBytes(fieldNumber
, (ByteString
) value
);
660 public void writeBytesList(int fieldNumber
, List
<ByteString
> value
) throws IOException
{
661 for (int i
= 0; i
< value
.size(); ++i
) {
662 output
.writeBytes(fieldNumber
, value
.get(i
));
667 public void writeUInt32List(int fieldNumber
, List
<Integer
> value
, boolean packed
)
669 if (value
instanceof IntArrayList
) {
670 writeUInt32ListInternal(fieldNumber
, (IntArrayList
) value
, packed
);
672 writeUInt32ListInternal(fieldNumber
, value
, packed
);
676 private void writeUInt32ListInternal(int fieldNumber
, IntArrayList value
, boolean packed
)
679 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
681 // Compute and write the length of the data.
683 for (int i
= 0; i
< value
.size(); ++i
) {
684 dataSize
+= CodedOutputStream
.computeUInt32SizeNoTag(value
.getInt(i
));
686 output
.writeUInt32NoTag(dataSize
);
688 // Write the data itself, without any tags.
689 for (int i
= 0; i
< value
.size(); ++i
) {
690 output
.writeUInt32NoTag(value
.getInt(i
));
693 for (int i
= 0; i
< value
.size(); ++i
) {
694 output
.writeUInt32(fieldNumber
, value
.getInt(i
));
699 public void writeUInt32ListInternal(int fieldNumber
, List
<Integer
> value
, boolean packed
)
702 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
704 // Compute and write the length of the data.
706 for (int i
= 0; i
< value
.size(); ++i
) {
707 dataSize
+= CodedOutputStream
.computeUInt32SizeNoTag(value
.get(i
));
709 output
.writeUInt32NoTag(dataSize
);
711 // Write the data itself, without any tags.
712 for (int i
= 0; i
< value
.size(); ++i
) {
713 output
.writeUInt32NoTag(value
.get(i
));
716 for (int i
= 0; i
< value
.size(); ++i
) {
717 output
.writeUInt32(fieldNumber
, value
.get(i
));
723 public void writeSFixed32List(int fieldNumber
, List
<Integer
> value
, boolean packed
)
725 if (value
instanceof IntArrayList
) {
726 writeSFixed32ListInternal(fieldNumber
, (IntArrayList
) value
, packed
);
728 writeSFixed32ListInternal(fieldNumber
, value
, packed
);
732 private void writeSFixed32ListInternal(int fieldNumber
, IntArrayList value
, boolean packed
)
735 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
737 // Compute and write the length of the data.
739 for (int i
= 0; i
< value
.size(); ++i
) {
740 dataSize
+= CodedOutputStream
.computeSFixed32SizeNoTag(value
.getInt(i
));
742 output
.writeUInt32NoTag(dataSize
);
744 // Write the data itself, without any tags.
745 for (int i
= 0; i
< value
.size(); ++i
) {
746 output
.writeSFixed32NoTag(value
.getInt(i
));
749 for (int i
= 0; i
< value
.size(); ++i
) {
750 output
.writeSFixed32(fieldNumber
, value
.getInt(i
));
755 private void writeSFixed32ListInternal(int fieldNumber
, List
<Integer
> value
, boolean packed
)
758 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
760 // Compute and write the length of the data.
762 for (int i
= 0; i
< value
.size(); ++i
) {
763 dataSize
+= CodedOutputStream
.computeSFixed32SizeNoTag(value
.get(i
));
765 output
.writeUInt32NoTag(dataSize
);
767 // Write the data itself, without any tags.
768 for (int i
= 0; i
< value
.size(); ++i
) {
769 output
.writeSFixed32NoTag(value
.get(i
));
772 for (int i
= 0; i
< value
.size(); ++i
) {
773 output
.writeSFixed32(fieldNumber
, value
.get(i
));
779 public void writeSFixed64List(int fieldNumber
, List
<Long
> value
, boolean packed
)
781 if (value
instanceof LongArrayList
) {
782 writeSFixed64ListInternal(fieldNumber
, (LongArrayList
) value
, packed
);
784 writeSFixed64ListInternal(fieldNumber
, value
, packed
);
788 private void writeSFixed64ListInternal(int fieldNumber
, LongArrayList value
, boolean packed
)
791 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
793 // Compute and write the length of the data.
795 for (int i
= 0; i
< value
.size(); ++i
) {
796 dataSize
+= CodedOutputStream
.computeSFixed64SizeNoTag(value
.getLong(i
));
798 output
.writeUInt32NoTag(dataSize
);
800 // Write the data itself, without any tags.
801 for (int i
= 0; i
< value
.size(); ++i
) {
802 output
.writeSFixed64NoTag(value
.getLong(i
));
805 for (int i
= 0; i
< value
.size(); ++i
) {
806 output
.writeSFixed64(fieldNumber
, value
.getLong(i
));
811 private void writeSFixed64ListInternal(int fieldNumber
, List
<Long
> value
, boolean packed
)
814 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
816 // Compute and write the length of the data.
818 for (int i
= 0; i
< value
.size(); ++i
) {
819 dataSize
+= CodedOutputStream
.computeSFixed64SizeNoTag(value
.get(i
));
821 output
.writeUInt32NoTag(dataSize
);
823 // Write the data itself, without any tags.
824 for (int i
= 0; i
< value
.size(); ++i
) {
825 output
.writeSFixed64NoTag(value
.get(i
));
828 for (int i
= 0; i
< value
.size(); ++i
) {
829 output
.writeSFixed64(fieldNumber
, value
.get(i
));
835 public void writeSInt32List(int fieldNumber
, List
<Integer
> value
, boolean packed
)
837 if (value
instanceof IntArrayList
) {
838 writeSInt32ListInternal(fieldNumber
, (IntArrayList
) value
, packed
);
840 writeSInt32ListInternal(fieldNumber
, value
, packed
);
844 private void writeSInt32ListInternal(int fieldNumber
, IntArrayList value
, boolean packed
)
847 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
849 // Compute and write the length of the data.
851 for (int i
= 0; i
< value
.size(); ++i
) {
852 dataSize
+= CodedOutputStream
.computeSInt32SizeNoTag(value
.getInt(i
));
854 output
.writeUInt32NoTag(dataSize
);
856 // Write the data itself, without any tags.
857 for (int i
= 0; i
< value
.size(); ++i
) {
858 output
.writeSInt32NoTag(value
.getInt(i
));
861 for (int i
= 0; i
< value
.size(); ++i
) {
862 output
.writeSInt32(fieldNumber
, value
.getInt(i
));
867 public void writeSInt32ListInternal(int fieldNumber
, List
<Integer
> value
, boolean packed
)
870 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
872 // Compute and write the length of the data.
874 for (int i
= 0; i
< value
.size(); ++i
) {
875 dataSize
+= CodedOutputStream
.computeSInt32SizeNoTag(value
.get(i
));
877 output
.writeUInt32NoTag(dataSize
);
879 // Write the data itself, without any tags.
880 for (int i
= 0; i
< value
.size(); ++i
) {
881 output
.writeSInt32NoTag(value
.get(i
));
884 for (int i
= 0; i
< value
.size(); ++i
) {
885 output
.writeSInt32(fieldNumber
, value
.get(i
));
891 public void writeSInt64List(int fieldNumber
, List
<Long
> value
, boolean packed
)
893 if (value
instanceof LongArrayList
) {
894 writeSInt64ListInternal(fieldNumber
, (LongArrayList
) value
, packed
);
896 writeSInt64ListInternal(fieldNumber
, value
, packed
);
900 private void writeSInt64ListInternal(int fieldNumber
, LongArrayList value
, boolean packed
)
903 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
905 // Compute and write the length of the data.
907 for (int i
= 0; i
< value
.size(); ++i
) {
908 dataSize
+= CodedOutputStream
.computeSInt64SizeNoTag(value
.getLong(i
));
910 output
.writeUInt32NoTag(dataSize
);
912 // Write the data itself, without any tags.
913 for (int i
= 0; i
< value
.size(); ++i
) {
914 output
.writeSInt64NoTag(value
.getLong(i
));
917 for (int i
= 0; i
< value
.size(); ++i
) {
918 output
.writeSInt64(fieldNumber
, value
.getLong(i
));
923 private void writeSInt64ListInternal(int fieldNumber
, List
<Long
> value
, boolean packed
)
926 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
928 // Compute and write the length of the data.
930 for (int i
= 0; i
< value
.size(); ++i
) {
931 dataSize
+= CodedOutputStream
.computeSInt64SizeNoTag(value
.get(i
));
933 output
.writeUInt32NoTag(dataSize
);
935 // Write the data itself, without any tags.
936 for (int i
= 0; i
< value
.size(); ++i
) {
937 output
.writeSInt64NoTag(value
.get(i
));
940 for (int i
= 0; i
< value
.size(); ++i
) {
941 output
.writeSInt64(fieldNumber
, value
.get(i
));
947 public void writeMessageList(int fieldNumber
, List
<?
> value
) throws IOException
{
948 for (int i
= 0; i
< value
.size(); ++i
) {
949 writeMessage(fieldNumber
, value
.get(i
));
954 public void writeMessageList(int fieldNumber
, List
<?
> value
, Schema schema
) throws IOException
{
955 for (int i
= 0; i
< value
.size(); ++i
) {
956 writeMessage(fieldNumber
, value
.get(i
), schema
);
962 public void writeGroupList(int fieldNumber
, List
<?
> value
) throws IOException
{
963 for (int i
= 0; i
< value
.size(); ++i
) {
964 writeGroup(fieldNumber
, value
.get(i
));
969 public void writeGroupList(int fieldNumber
, List
<?
> value
, Schema schema
) throws IOException
{
970 for (int i
= 0; i
< value
.size(); ++i
) {
971 writeGroup(fieldNumber
, value
.get(i
), schema
);
976 public <K
, V
> void writeMap(int fieldNumber
, MapEntryLite
.Metadata
<K
, V
> metadata
, Map
<K
, V
> map
)
978 if (output
.isSerializationDeterministic()) {
979 writeDeterministicMap(fieldNumber
, metadata
, map
);
982 for (Map
.Entry
<K
, V
> entry
: map
.entrySet()) {
983 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
984 output
.writeUInt32NoTag(
985 MapEntryLite
.computeSerializedSize(metadata
, entry
.getKey(), entry
.getValue()));
986 MapEntryLite
.writeTo(output
, metadata
, entry
.getKey(), entry
.getValue());
990 @SuppressWarnings("unchecked")
991 private <K
, V
> void writeDeterministicMap(
992 int fieldNumber
, MapEntryLite
.Metadata
<K
, V
> metadata
, Map
<K
, V
> map
) throws IOException
{
993 switch (metadata
.keyType
) {
996 if ((value
= map
.get(Boolean
.FALSE
)) != null) {
997 writeDeterministicBooleanMapEntry(
998 fieldNumber
, /* key= */ false, value
, (MapEntryLite
.Metadata
<Boolean
, V
>) metadata
);
1000 if ((value
= map
.get(Boolean
.TRUE
)) != null) {
1001 writeDeterministicBooleanMapEntry(
1002 fieldNumber
, /* key= */ true, value
, (MapEntryLite
.Metadata
<Boolean
, V
>) metadata
);
1010 writeDeterministicIntegerMap(
1011 fieldNumber
, (MapEntryLite
.Metadata
<Integer
, V
>) metadata
, (Map
<Integer
, V
>) map
);
1018 writeDeterministicLongMap(
1019 fieldNumber
, (MapEntryLite
.Metadata
<Long
, V
>) metadata
, (Map
<Long
, V
>) map
);
1022 writeDeterministicStringMap(
1023 fieldNumber
, (MapEntryLite
.Metadata
<String
, V
>) metadata
, (Map
<String
, V
>) map
);
1026 throw new IllegalArgumentException("does not support key type: " + metadata
.keyType
);
1030 private <V
> void writeDeterministicBooleanMapEntry(
1031 int fieldNumber
, boolean key
, V value
, MapEntryLite
.Metadata
<Boolean
, V
> metadata
)
1032 throws IOException
{
1033 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
1034 output
.writeUInt32NoTag(MapEntryLite
.computeSerializedSize(metadata
, key
, value
));
1035 MapEntryLite
.writeTo(output
, metadata
, key
, value
);
1038 private <V
> void writeDeterministicIntegerMap(
1039 int fieldNumber
, MapEntryLite
.Metadata
<Integer
, V
> metadata
, Map
<Integer
, V
> map
)
1040 throws IOException
{
1041 int[] keys
= new int[map
.size()];
1043 for (int k
: map
.keySet()) {
1047 for (int key
: keys
) {
1048 V value
= map
.get(key
);
1049 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
1050 output
.writeUInt32NoTag(MapEntryLite
.computeSerializedSize(metadata
, key
, value
));
1051 MapEntryLite
.writeTo(output
, metadata
, key
, value
);
1055 private <V
> void writeDeterministicLongMap(
1056 int fieldNumber
, MapEntryLite
.Metadata
<Long
, V
> metadata
, Map
<Long
, V
> map
)
1057 throws IOException
{
1058 long[] keys
= new long[map
.size()];
1060 for (long k
: map
.keySet()) {
1064 for (long key
: keys
) {
1065 V value
= map
.get(key
);
1066 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
1067 output
.writeUInt32NoTag(MapEntryLite
.computeSerializedSize(metadata
, key
, value
));
1068 MapEntryLite
.writeTo(output
, metadata
, key
, value
);
1072 private <V
> void writeDeterministicStringMap(
1073 int fieldNumber
, MapEntryLite
.Metadata
<String
, V
> metadata
, Map
<String
, V
> map
)
1074 throws IOException
{
1075 String
[] keys
= new String
[map
.size()];
1077 for (String k
: map
.keySet()) {
1081 for (String key
: keys
) {
1082 V value
= map
.get(key
);
1083 output
.writeTag(fieldNumber
, WIRETYPE_LENGTH_DELIMITED
);
1084 output
.writeUInt32NoTag(MapEntryLite
.computeSerializedSize(metadata
, key
, value
));
1085 MapEntryLite
.writeTo(output
, metadata
, key
, value
);