Google Git
Sign in
android / platform / frameworks / base / 86ac001419f140ed849eec83e1c42eb1c75860a7 / . / core / java / android / util / proto / ProtoOutputStream.java
blob: 9afa56dd57e4c29d509e97cfa3d56044c0382dd1 [file] [log] [blame]
/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.util.proto;
import android.annotation.TestApi;
import android.util.Log;
import java.io.FileDescriptor;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
/**
* Class to write to a protobuf stream.
*
* Each write method takes an ID code from the protoc generated classes
* and the value to write. To make a nested object, call startObject
* and then endObject when you are done.
*
* The ID codes have type information embedded into them, so if you call
* the incorrect function you will get an IllegalArgumentException.
*
* To retrieve the encoded protobuf stream, call getBytes().
*
* TODO: Add a constructor that takes an OutputStream and write to that
* stream as the top-level objects are finished.
*
* @hide
*/
/* IMPLEMENTATION NOTES
*
* Because protobuf has inner values, and they are length prefixed, and
* those sizes themselves are stored with a variable length encoding, it
* is impossible to know how big an object will be in a single pass.
*
* The traditional way is to copy the in-memory representation of an object
* into the generated proto Message objects, do a traversal of those to
* cache the size, and then write the size-prefixed buffers.
*
* We are trying to avoid too much generated code here, but this class still
* needs to have a somewhat sane API. We can't have the multiple passes be
* done by the calling code. In addition, we want to avoid the memory high
* water mark of duplicating all of the values into the traditional in-memory
* Message objects. We need to find another way.
*
* So what we do here is to let the calling code write the data into a
* byte[] (actually a collection of them wrapped in the EncodedBuffer) class,
* but not do the varint encoding of the sub-message sizes. Then, we do a
* recursive traversal of the buffer itself, calculating the sizes (which are
* then knowable, although still not the actual sizes in the buffer because of
* possible further nesting). Then we do a third pass, compacting the
* buffer and varint encoding the sizes.
*
* This gets us a relatively small number number of fixed-size allocations,
* which is less likely to cause memory fragmentation or churn the GC, and
* the same number of data copies as would have gotten with setting it
* field-by-field in generated code, and no code bloat from generated code.
* The final data copy is also done with System.arraycopy, which will be
* more efficient, in general, than doing the individual fields twice (as in
* the traditional way).
*
* To accomplish the multiple passes, whenever we write a
* WIRE_TYPE_LENGTH_DELIMITED field, we write the size occupied in our
* buffer as a fixed 32 bit int (called childRawSize), not variable length
* one. We reserve another 32 bit slot for the computed size (called
* childEncodedSize). If we know the size up front, as we do for strings
* and byte[], then we also put that into childEncodedSize, if we don't, we
* write the negative of childRawSize, as a sentiel that we need to
* compute it during the second pass and recursively compact it during the
* third pass.
*
* Unsgigned size varints can be up to five bytes long, but we reserve eight
* bytes for overhead, so we know that when we compact the buffer, there
* will always be space for the encoded varint.
*
* When we can figure out the size ahead of time, we do, in order
* to save overhead with recalculating it, and with the later arraycopy.
*
* During the period between when the caller has called startObject, but
* not yet called endObject, we maintain a linked list of the tokens
* returned by startObject, stored in those 8 bytes of size storage space.
* We use that linked list of tokens to ensure that the caller has
* correctly matched pairs of startObject and endObject calls, and issue
* errors if they are not matched.
*/
@TestApi
public final class ProtoOutputStream {
public static final String TAG = "ProtoOutputStream";
public static final int FIELD_ID_SHIFT = 3;
public static final int WIRE_TYPE_MASK = (1<<FIELD_ID_SHIFT)-1;
public static final int FIELD_ID_MASK = ~WIRE_TYPE_MASK;
public static final int WIRE_TYPE_VARINT = 0;
public static final int WIRE_TYPE_FIXED64 = 1;
public static final int WIRE_TYPE_LENGTH_DELIMITED = 2;
public static final int WIRE_TYPE_START_GROUP = 3;
public static final int WIRE_TYPE_END_GROUP = 4;
public static final int WIRE_TYPE_FIXED32 = 5;
/**
* Position of the field type in a (long) fieldId.
*/
public static final int FIELD_TYPE_SHIFT = 32;
/**
* Mask for the field types stored in a fieldId. Leaves a whole
* byte for future expansion, even though there are currently only 17 types.
*/
public static final long FIELD_TYPE_MASK = 0x0ffL << FIELD_TYPE_SHIFT;
public static final long FIELD_TYPE_UNKNOWN = 0;
public static final long FIELD_TYPE_DOUBLE = 1L << FIELD_TYPE_SHIFT;
public static final long FIELD_TYPE_FLOAT = 2L << FIELD_TYPE_SHIFT;
public static final long FIELD_TYPE_INT32 = 3L << FIELD_TYPE_SHIFT;
public static final long FIELD_TYPE_INT64 = 4L << FIELD_TYPE_SHIFT;
public static final long FIELD_TYPE_UINT32 = 5L << FIELD_TYPE_SHIFT;
public static final long FIELD_TYPE_UINT64 = 6L << FIELD_TYPE_SHIFT;
public static final long FIELD_TYPE_SINT32 = 7L << FIELD_TYPE_SHIFT;
public static final long FIELD_TYPE_SINT64 = 8L << FIELD_TYPE_SHIFT;
public static final long FIELD_TYPE_FIXED32 = 9L << FIELD_TYPE_SHIFT;
public static final long FIELD_TYPE_FIXED64 = 10L << FIELD_TYPE_SHIFT;
public static final long FIELD_TYPE_SFIXED32 = 11L << FIELD_TYPE_SHIFT;
public static final long FIELD_TYPE_SFIXED64 = 12L << FIELD_TYPE_SHIFT;
public static final long FIELD_TYPE_BOOL = 13L << FIELD_TYPE_SHIFT;
public static final long FIELD_TYPE_STRING = 14L << FIELD_TYPE_SHIFT;
public static final long FIELD_TYPE_BYTES = 15L << FIELD_TYPE_SHIFT;
public static final long FIELD_TYPE_ENUM = 16L << FIELD_TYPE_SHIFT;
public static final long FIELD_TYPE_OBJECT = 17L << FIELD_TYPE_SHIFT;
private static final String[] FIELD_TYPE_NAMES = new String[] {
"Double",
"Float",
"Int32",
"Int64",
"UInt32",
"UInt64",
"SInt32",
"SInt64",
"Fixed32",
"Fixed64",
"SFixed32",
"SFixed64",
"Bool",
"String",
"Bytes",
"Enum",
"Object",
};
//
// FieldId flags for whether the field is single, repeated or packed.
//
public static final int FIELD_COUNT_SHIFT = 40;
public static final long FIELD_COUNT_MASK = 0x0fL << FIELD_COUNT_SHIFT;
public static final long FIELD_COUNT_UNKNOWN = 0;
public static final long FIELD_COUNT_SINGLE = 1L << FIELD_COUNT_SHIFT;
public static final long FIELD_COUNT_REPEATED = 2L << FIELD_COUNT_SHIFT;
public static final long FIELD_COUNT_PACKED = 5L << FIELD_COUNT_SHIFT;
/**
* Our buffer.
*/
private EncodedBuffer mBuffer;
/**
* Our stream. If there is one.
*/
private OutputStream mStream;
/**
* Current nesting depth of startObject calls.
*/
private int mDepth;
/**
* An ID given to objects and returned in the token from startObject
* and stored in the buffer until endObject is called, where the two
* are checked. Starts at -1 and becomes more negative, so the values
* aren't likely to alias with the size it will be overwritten with,
* which tend to be small, and we will be more likely to catch when
* the caller of endObject uses a stale token that they didn't intend
* to (e.g. copy and paste error).
*/
private int mNextObjectId = -1;
/**
* The object token we are expecting in endObject. If another call to
* startObject happens, this is written to that location, which gives
* us a stack, stored in the space for the as-yet unused size fields.
*/
private long mExpectedObjectToken;
/**
* Index in mBuffer that we should start copying from on the next
* pass of compaction.
*/
private int mCopyBegin;
/**
* Whether we've already compacted
*/
private boolean mCompacted;
/**
* Construct a ProtoOutputStream with the default chunk size.
*/
public ProtoOutputStream() {
this(0);
}
/**
* Construct a ProtoOutputStream with the given chunk size.
*/
public ProtoOutputStream(int chunkSize) {
mBuffer = new EncodedBuffer(chunkSize);
}
/**
* Construct a ProtoOutputStream that sits on top of an OutputStream.
* @more
* The {@link #flush() flush()} method must be called when done writing
* to flush any remanining data, althought data *may* be written at intermediate
* points within the writing as well.
*/
public ProtoOutputStream(OutputStream stream) {
this();
mStream = stream;
}
/**
* Construct a ProtoOutputStream that sits on top of a FileDescriptor.
* @more
* The {@link #flush() flush()} method must be called when done writing
* to flush any remanining data, althought data *may* be written at intermediate
* points within the writing as well.
*/
public ProtoOutputStream(FileDescriptor fd) {
this(new FileOutputStream(fd));
}
/**
* Write a value for the given fieldId.
*
* Will automatically convert for the following field types, and
* throw an exception for others: double, float, int32, int64, uint32, uint64,
* sint32, sint64, fixed32, fixed64, sfixed32, sfixed64, bool, enum.
*
* @param fieldId The field identifier constant from the generated class.
* @param val The value.
*/
public void write(long fieldId, double val) {
assertNotCompacted();
final int id = (int)fieldId;
switch ((int)((fieldId & (FIELD_TYPE_MASK | FIELD_COUNT_MASK)) >> FIELD_TYPE_SHIFT)) {
// double
case (int)((FIELD_TYPE_DOUBLE | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeDoubleImpl(id, (double)val);
break;
case (int)((FIELD_TYPE_DOUBLE | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_DOUBLE | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedDoubleImpl(id, (double)val);
break;
// float
case (int)((FIELD_TYPE_FLOAT | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeFloatImpl(id, (float)val);
break;
case (int)((FIELD_TYPE_FLOAT | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_FLOAT | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedFloatImpl(id, (float)val);
break;
// int32
case (int)((FIELD_TYPE_INT32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeInt32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_INT32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_INT32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedInt32Impl(id, (int)val);
break;
// int64
case (int)((FIELD_TYPE_INT64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeInt64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_INT64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_INT64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedInt64Impl(id, (long)val);
break;
// uint32
case (int)((FIELD_TYPE_UINT32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeUInt32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_UINT32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_UINT32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedUInt32Impl(id, (int)val);
break;
// uint64
case (int)((FIELD_TYPE_UINT64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeUInt64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_UINT64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_UINT64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedUInt64Impl(id, (long)val);
break;
// sint32
case (int)((FIELD_TYPE_SINT32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeSInt32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_SINT32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_SINT32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedSInt32Impl(id, (int)val);
break;
// sint64
case (int)((FIELD_TYPE_SINT64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeSInt64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_SINT64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_SINT64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedSInt64Impl(id, (long)val);
break;
// fixed32
case (int)((FIELD_TYPE_FIXED32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeFixed32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_FIXED32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_FIXED32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedFixed32Impl(id, (int)val);
break;
// fixed64
case (int)((FIELD_TYPE_FIXED64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeFixed64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_FIXED64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_FIXED64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedFixed64Impl(id, (long)val);
break;
// sfixed32
case (int)((FIELD_TYPE_SFIXED32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeSFixed32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_SFIXED32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_SFIXED32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedSFixed32Impl(id, (int)val);
break;
// sfixed64
case (int)((FIELD_TYPE_SFIXED64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeSFixed64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_SFIXED64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_SFIXED64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedSFixed64Impl(id, (long)val);
break;
// bool
case (int)((FIELD_TYPE_BOOL | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeBoolImpl(id, val != 0);
break;
case (int)((FIELD_TYPE_BOOL | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_BOOL | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedBoolImpl(id, val != 0);
break;
// enum
case (int)((FIELD_TYPE_ENUM | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeEnumImpl(id, (int)val);
break;
case (int)((FIELD_TYPE_ENUM | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_ENUM | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedEnumImpl(id, (int)val);
break;
// string, bytes, object not allowed here.
default: {
throw new IllegalArgumentException("Attempt to call write(long, double) with "
+ getFieldIdString(fieldId));
}
}
}
/**
* Write a value for the given fieldId.
*
* Will automatically convert for the following field types, and
* throw an exception for others: double, float, int32, int64, uint32, uint64,
* sint32, sint64, fixed32, fixed64, sfixed32, sfixed64, bool, enum.
*
* @param fieldId The field identifier constant from the generated class.
* @param val The value.
*/
public void write(long fieldId, float val) {
assertNotCompacted();
final int id = (int)fieldId;
switch ((int)((fieldId & (FIELD_TYPE_MASK | FIELD_COUNT_MASK)) >> FIELD_TYPE_SHIFT)) {
// double
case (int)((FIELD_TYPE_DOUBLE | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeDoubleImpl(id, (double)val);
break;
case (int)((FIELD_TYPE_DOUBLE | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_DOUBLE | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedDoubleImpl(id, (double)val);
break;
// float
case (int)((FIELD_TYPE_FLOAT | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeFloatImpl(id, (float)val);
break;
case (int)((FIELD_TYPE_FLOAT | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_FLOAT | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedFloatImpl(id, (float)val);
break;
// int32
case (int)((FIELD_TYPE_INT32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeInt32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_INT32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_INT32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedInt32Impl(id, (int)val);
break;
// int64
case (int)((FIELD_TYPE_INT64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeInt64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_INT64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_INT64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedInt64Impl(id, (long)val);
break;
// uint32
case (int)((FIELD_TYPE_UINT32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeUInt32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_UINT32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_UINT32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedUInt32Impl(id, (int)val);
break;
// uint64
case (int)((FIELD_TYPE_UINT64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeUInt64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_UINT64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_UINT64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedUInt64Impl(id, (long)val);
break;
// sint32
case (int)((FIELD_TYPE_SINT32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeSInt32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_SINT32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_SINT32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedSInt32Impl(id, (int)val);
break;
// sint64
case (int)((FIELD_TYPE_SINT64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeSInt64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_SINT64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_SINT64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedSInt64Impl(id, (long)val);
break;
// fixed32
case (int)((FIELD_TYPE_FIXED32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeFixed32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_FIXED32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_FIXED32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedFixed32Impl(id, (int)val);
break;
// fixed64
case (int)((FIELD_TYPE_FIXED64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeFixed64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_FIXED64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_FIXED64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedFixed64Impl(id, (long)val);
break;
// sfixed32
case (int)((FIELD_TYPE_SFIXED32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeSFixed32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_SFIXED32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_SFIXED32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedSFixed32Impl(id, (int)val);
break;
// sfixed64
case (int)((FIELD_TYPE_SFIXED64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeSFixed64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_SFIXED64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_SFIXED64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedSFixed64Impl(id, (long)val);
break;
// bool
case (int)((FIELD_TYPE_BOOL | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeBoolImpl(id, val != 0);
break;
case (int)((FIELD_TYPE_BOOL | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_BOOL | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedBoolImpl(id, val != 0);
break;
// enum
case (int)((FIELD_TYPE_ENUM | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeEnumImpl(id, (int)val);
break;
case (int)((FIELD_TYPE_ENUM | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_ENUM | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedEnumImpl(id, (int)val);
break;
// string, bytes, object not allowed here.
default: {
throw new IllegalArgumentException("Attempt to call write(long, float) with "
+ getFieldIdString(fieldId));
}
}
}
/**
* Write a value for the given fieldId.
*
* Will automatically convert for the following field types, and
* throw an exception for others: double, float, int32, int64, uint32, uint64,
* sint32, sint64, fixed32, fixed64, sfixed32, sfixed64, bool, enum.
*
* @param fieldId The field identifier constant from the generated class.
* @param val The value.
*/
public void write(long fieldId, int val) {
assertNotCompacted();
final int id = (int)fieldId;
switch ((int)((fieldId & (FIELD_TYPE_MASK | FIELD_COUNT_MASK)) >> FIELD_TYPE_SHIFT)) {
// double
case (int)((FIELD_TYPE_DOUBLE | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeDoubleImpl(id, (double)val);
break;
case (int)((FIELD_TYPE_DOUBLE | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_DOUBLE | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedDoubleImpl(id, (double)val);
break;
// float
case (int)((FIELD_TYPE_FLOAT | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeFloatImpl(id, (float)val);
break;
case (int)((FIELD_TYPE_FLOAT | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_FLOAT | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedFloatImpl(id, (float)val);
break;
// int32
case (int)((FIELD_TYPE_INT32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeInt32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_INT32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_INT32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedInt32Impl(id, (int)val);
break;
// int64
case (int)((FIELD_TYPE_INT64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeInt64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_INT64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_INT64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedInt64Impl(id, (long)val);
break;
// uint32
case (int)((FIELD_TYPE_UINT32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeUInt32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_UINT32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_UINT32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedUInt32Impl(id, (int)val);
break;
// uint64
case (int)((FIELD_TYPE_UINT64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeUInt64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_UINT64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_UINT64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedUInt64Impl(id, (long)val);
break;
// sint32
case (int)((FIELD_TYPE_SINT32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeSInt32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_SINT32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_SINT32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedSInt32Impl(id, (int)val);
break;
// sint64
case (int)((FIELD_TYPE_SINT64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeSInt64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_SINT64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_SINT64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedSInt64Impl(id, (long)val);
break;
// fixed32
case (int)((FIELD_TYPE_FIXED32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeFixed32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_FIXED32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_FIXED32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedFixed32Impl(id, (int)val);
break;
// fixed64
case (int)((FIELD_TYPE_FIXED64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeFixed64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_FIXED64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_FIXED64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedFixed64Impl(id, (long)val);
break;
// sfixed32
case (int)((FIELD_TYPE_SFIXED32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeSFixed32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_SFIXED32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_SFIXED32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedSFixed32Impl(id, (int)val);
break;
// sfixed64
case (int)((FIELD_TYPE_SFIXED64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeSFixed64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_SFIXED64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_SFIXED64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedSFixed64Impl(id, (long)val);
break;
// bool
case (int)((FIELD_TYPE_BOOL | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeBoolImpl(id, val != 0);
break;
case (int)((FIELD_TYPE_BOOL | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_BOOL | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedBoolImpl(id, val != 0);
break;
// enum
case (int)((FIELD_TYPE_ENUM | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeEnumImpl(id, (int)val);
break;
case (int)((FIELD_TYPE_ENUM | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_ENUM | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedEnumImpl(id, (int)val);
break;
// string, bytes, object not allowed here.
default: {
throw new IllegalArgumentException("Attempt to call write(long, int) with "
+ getFieldIdString(fieldId));
}
}
}
/**
* Write a value for the given fieldId.
*
* Will automatically convert for the following field types, and
* throw an exception for others: double, float, int32, int64, uint32, uint64,
* sint32, sint64, fixed32, fixed64, sfixed32, sfixed64, bool, enum.
*
* @param fieldId The field identifier constant from the generated class.
* @param val The value.
*/
public void write(long fieldId, long val) {
assertNotCompacted();
final int id = (int)fieldId;
switch ((int)((fieldId & (FIELD_TYPE_MASK | FIELD_COUNT_MASK)) >> FIELD_TYPE_SHIFT)) {
// double
case (int)((FIELD_TYPE_DOUBLE | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeDoubleImpl(id, (double)val);
break;
case (int)((FIELD_TYPE_DOUBLE | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_DOUBLE | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedDoubleImpl(id, (double)val);
break;
// float
case (int)((FIELD_TYPE_FLOAT | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeFloatImpl(id, (float)val);
break;
case (int)((FIELD_TYPE_FLOAT | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_FLOAT | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedFloatImpl(id, (float)val);
break;
// int32
case (int)((FIELD_TYPE_INT32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeInt32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_INT32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_INT32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedInt32Impl(id, (int)val);
break;
// int64
case (int)((FIELD_TYPE_INT64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeInt64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_INT64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_INT64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedInt64Impl(id, (long)val);
break;
// uint32
case (int)((FIELD_TYPE_UINT32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeUInt32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_UINT32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_UINT32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedUInt32Impl(id, (int)val);
break;
// uint64
case (int)((FIELD_TYPE_UINT64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeUInt64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_UINT64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_UINT64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedUInt64Impl(id, (long)val);
break;
// sint32
case (int)((FIELD_TYPE_SINT32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeSInt32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_SINT32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_SINT32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedSInt32Impl(id, (int)val);
break;
// sint64
case (int)((FIELD_TYPE_SINT64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeSInt64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_SINT64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_SINT64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedSInt64Impl(id, (long)val);
break;
// fixed32
case (int)((FIELD_TYPE_FIXED32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeFixed32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_FIXED32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_FIXED32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedFixed32Impl(id, (int)val);
break;
// fixed64
case (int)((FIELD_TYPE_FIXED64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeFixed64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_FIXED64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_FIXED64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedFixed64Impl(id, (long)val);
break;
// sfixed32
case (int)((FIELD_TYPE_SFIXED32 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeSFixed32Impl(id, (int)val);
break;
case (int)((FIELD_TYPE_SFIXED32 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_SFIXED32 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedSFixed32Impl(id, (int)val);
break;
// sfixed64
case (int)((FIELD_TYPE_SFIXED64 | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeSFixed64Impl(id, (long)val);
break;
case (int)((FIELD_TYPE_SFIXED64 | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_SFIXED64 | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedSFixed64Impl(id, (long)val);
break;
// bool
case (int)((FIELD_TYPE_BOOL | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeBoolImpl(id, val != 0);
break;
case (int)((FIELD_TYPE_BOOL | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_BOOL | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedBoolImpl(id, val != 0);
break;
// enum
case (int)((FIELD_TYPE_ENUM | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeEnumImpl(id, (int)val);
break;
case (int)((FIELD_TYPE_ENUM | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_ENUM | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedEnumImpl(id, (int)val);
break;
// string, bytes, object not allowed here.
default: {
throw new IllegalArgumentException("Attempt to call write(long, long) with "
+ getFieldIdString(fieldId));
}
}
}
/**
* Write a boolean value for the given fieldId.
*
* If the field is not a bool field, an exception will be thrown.
*
* @param fieldId The field identifier constant from the generated class.
* @param val The value.
*/
public void write(long fieldId, boolean val) {
assertNotCompacted();
final int id = (int)fieldId;
switch ((int)((fieldId & (FIELD_TYPE_MASK | FIELD_COUNT_MASK)) >> FIELD_TYPE_SHIFT)) {
// bool
case (int)((FIELD_TYPE_BOOL | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeBoolImpl(id, val);
break;
case (int)((FIELD_TYPE_BOOL | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_BOOL | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedBoolImpl(id, val);
break;
// nothing else allowed
default: {
throw new IllegalArgumentException("Attempt to call write(long, boolean) with "
+ getFieldIdString(fieldId));
}
}
}
/**
* Write a string value for the given fieldId.
*
* If the field is not a string field, an exception will be thrown.
*
* @param fieldId The field identifier constant from the generated class.
* @param val The value.
*/
public void write(long fieldId, String val) {
assertNotCompacted();
final int id = (int)fieldId;
switch ((int)((fieldId & (FIELD_TYPE_MASK | FIELD_COUNT_MASK)) >> FIELD_TYPE_SHIFT)) {
// string
case (int)((FIELD_TYPE_STRING | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeStringImpl(id, val);
break;
case (int)((FIELD_TYPE_STRING | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_STRING | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedStringImpl(id, val);
break;
// nothing else allowed
default: {
throw new IllegalArgumentException("Attempt to call write(long, String) with "
+ getFieldIdString(fieldId));
}
}
}
/**
* Write a byte[] value for the given fieldId.
*
* If the field is not a bytes or object field, an exception will be thrown.
*
* @param fieldId The field identifier constant from the generated class.
* @param val The value.
*/
public void write(long fieldId, byte[] val) {
assertNotCompacted();
final int id = (int)fieldId;
switch ((int)((fieldId & (FIELD_TYPE_MASK | FIELD_COUNT_MASK)) >> FIELD_TYPE_SHIFT)) {
// bytes
case (int)((FIELD_TYPE_BYTES | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeBytesImpl(id, val);
break;
case (int)((FIELD_TYPE_BYTES | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_BYTES | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedBytesImpl(id, val);
break;
// Object
case (int)((FIELD_TYPE_OBJECT | FIELD_COUNT_SINGLE) >> FIELD_TYPE_SHIFT):
writeObjectImpl(id, val);
break;
case (int)((FIELD_TYPE_OBJECT | FIELD_COUNT_REPEATED) >> FIELD_TYPE_SHIFT):
case (int)((FIELD_TYPE_OBJECT | FIELD_COUNT_PACKED) >> FIELD_TYPE_SHIFT):
writeRepeatedObjectImpl(id, val);
break;
// nothing else allowed
default: {
throw new IllegalArgumentException("Attempt to call write(long, byte[]) with "
+ getFieldIdString(fieldId));
}
}
}
/**
* Start a sub object.
*/
public long start(long fieldId) {
assertNotCompacted();
final int id = (int)fieldId;
if ((fieldId & FIELD_TYPE_MASK) == FIELD_TYPE_OBJECT) {
final long count = fieldId & FIELD_COUNT_MASK;
if (count == FIELD_COUNT_SINGLE) {
return startObjectImpl(id, false);
} else if (count == FIELD_COUNT_REPEATED || count == FIELD_COUNT_PACKED) {
return startObjectImpl(id, true);
}
}
throw new IllegalArgumentException("Attempt to call start(long) with "
+ getFieldIdString(fieldId));
}
/**
* End the object started by start() that returned token.
*/
public void end(long token) {
endObjectImpl(token, getRepeatedFromToken(token));
}
//
// proto3 type: double
// java type: double
// encoding: fixed64
// wire type: WIRE_TYPE_FIXED64
//
/**
* Write a single proto "double" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeDouble(long fieldId, double val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_DOUBLE);
writeDoubleImpl(id, val);
}
private void writeDoubleImpl(int id, double val) {
if (val != 0) {
writeTag(id, WIRE_TYPE_FIXED64);
mBuffer.writeRawFixed64(Double.doubleToLongBits(val));
}
}
/**
* Write a single repeated proto "double" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeRepeatedDouble(long fieldId, double val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_DOUBLE);
writeRepeatedDoubleImpl(id, val);
}
private void writeRepeatedDoubleImpl(int id, double val) {
writeTag(id, WIRE_TYPE_FIXED64);
mBuffer.writeRawFixed64(Double.doubleToLongBits(val));
}
/**
* Write a list of packed proto "double" type field values.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writePackedDouble(long fieldId, double[] val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_PACKED | FIELD_TYPE_DOUBLE);
final int N = val != null ? val.length : 0;
if (N > 0) {
writeKnownLengthHeader(id, N * 8);
for (int i=0; i<N; i++) {
mBuffer.writeRawFixed64(Double.doubleToLongBits(val[i]));
}
}
}
//
// proto3 type: float
// java type: float
// encoding: fixed32
// wire type: WIRE_TYPE_FIXED32
//
/**
* Write a single proto "float" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeFloat(long fieldId, float val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_FLOAT);
writeFloatImpl(id, val);
}
private void writeFloatImpl(int id, float val) {
if (val != 0) {
writeTag(id, WIRE_TYPE_FIXED32);
mBuffer.writeRawFixed32(Float.floatToIntBits(val));
}
}
/**
* Write a single repeated proto "float" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeRepeatedFloat(long fieldId, float val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_FLOAT);
writeRepeatedFloatImpl(id, val);
}
private void writeRepeatedFloatImpl(int id, float val) {
writeTag(id, WIRE_TYPE_FIXED32);
mBuffer.writeRawFixed32(Float.floatToIntBits(val));
}
/**
* Write a list of packed proto "float" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writePackedFloat(long fieldId, float[] val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_PACKED | FIELD_TYPE_FLOAT);
final int N = val != null ? val.length : 0;
if (N > 0) {
writeKnownLengthHeader(id, N * 4);
for (int i=0; i<N; i++) {
mBuffer.writeRawFixed32(Float.floatToIntBits(val[i]));
}
}
}
//
// proto3 type: int32
// java type: int
// signed/unsigned: signed
// encoding: varint
// wire type: WIRE_TYPE_VARINT
//
/**
* Writes a java int as an usigned varint.
*
* The unadorned int32 type in protobuf is unfortunate because it
* is stored in memory as a signed value, but encodes as unsigned
* varints, which are formally always longs. So here, we encode
* negative values as 64 bits, which will get the sign-extension,
* and positive values as 32 bits, which saves a marginal amount
* of work in that it processes ints instead of longs.
*/
private void writeUnsignedVarintFromSignedInt(int val) {
if (val >= 0) {
mBuffer.writeRawVarint32(val);
} else {
mBuffer.writeRawVarint64(val);
}
}
/**
* Write a single proto "int32" type field value.
*
* Note that these are stored in memory as signed values and written as unsigned
* varints, which if negative, are 10 bytes long. If you know the data is likely
* to be negative, use "sint32".
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeInt32(long fieldId, int val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_INT32);
writeInt32Impl(id, val);
}
private void writeInt32Impl(int id, int val) {
if (val != 0) {
writeTag(id, WIRE_TYPE_VARINT);
writeUnsignedVarintFromSignedInt(val);
}
}
/**
* Write a single repeated proto "int32" type field value.
*
* Note that these are stored in memory as signed values and written as unsigned
* varints, which if negative, are 10 bytes long. If you know the data is likely
* to be negative, use "sint32".
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeRepeatedInt32(long fieldId, int val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_INT32);
writeRepeatedInt32Impl(id, val);
}
private void writeRepeatedInt32Impl(int id, int val) {
writeTag(id, WIRE_TYPE_VARINT);
writeUnsignedVarintFromSignedInt(val);
}
/**
* Write a list of packed proto "int32" type field value.
*
* Note that these are stored in memory as signed values and written as unsigned
* varints, which if negative, are 10 bytes long. If you know the data is likely
* to be negative, use "sint32".
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writePackedInt32(long fieldId, int[] val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_PACKED | FIELD_TYPE_INT32);
final int N = val != null ? val.length : 0;
if (N > 0) {
int size = 0;
for (int i=0; i<N; i++) {
final int v = val[i];
size += v >= 0 ? EncodedBuffer.getRawVarint32Size(v) : 10;
}
writeKnownLengthHeader(id, size);
for (int i=0; i<N; i++) {
writeUnsignedVarintFromSignedInt(val[i]);
}
}
}
//
// proto3 type: int64
// java type: int
// signed/unsigned: signed
// encoding: varint
// wire type: WIRE_TYPE_VARINT
//
/**
* Write a single proto "int64" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeInt64(long fieldId, long val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_INT64);
writeInt64Impl(id, val);
}
private void writeInt64Impl(int id, long val) {
if (val != 0) {
writeTag(id, WIRE_TYPE_VARINT);
mBuffer.writeRawVarint64(val);
}
}
/**
* Write a single repeated proto "int64" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeRepeatedInt64(long fieldId, long val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_INT64);
writeRepeatedInt64Impl(id, val);
}
private void writeRepeatedInt64Impl(int id, long val) {
writeTag(id, WIRE_TYPE_VARINT);
mBuffer.writeRawVarint64(val);
}
/**
* Write a list of packed proto "int64" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writePackedInt64(long fieldId, long[] val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_PACKED | FIELD_TYPE_INT64);
final int N = val != null ? val.length : 0;
if (N > 0) {
int size = 0;
for (int i=0; i<N; i++) {
size += EncodedBuffer.getRawVarint64Size(val[i]);
}
writeKnownLengthHeader(id, size);
for (int i=0; i<N; i++) {
mBuffer.writeRawVarint64(val[i]);
}
}
}
//
// proto3 type: uint32
// java type: int
// signed/unsigned: unsigned
// encoding: varint
// wire type: WIRE_TYPE_VARINT
//
/**
* Write a single proto "uint32" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeUInt32(long fieldId, int val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_UINT32);
writeUInt32Impl(id, val);
}
private void writeUInt32Impl(int id, int val) {
if (val != 0) {
writeTag(id, WIRE_TYPE_VARINT);
mBuffer.writeRawVarint32(val);
}
}
/**
* Write a single repeated proto "uint32" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeRepeatedUInt32(long fieldId, int val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_UINT32);
writeRepeatedUInt32Impl(id, val);
}
private void writeRepeatedUInt32Impl(int id, int val) {
writeTag(id, WIRE_TYPE_VARINT);
mBuffer.writeRawVarint32(val);
}
/**
* Write a list of packed proto "uint32" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writePackedUInt32(long fieldId, int[] val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_PACKED | FIELD_TYPE_UINT32);
final int N = val != null ? val.length : 0;
if (N > 0) {
int size = 0;
for (int i=0; i<N; i++) {
size += EncodedBuffer.getRawVarint32Size(val[i]);
}
writeKnownLengthHeader(id, size);
for (int i=0; i<N; i++) {
mBuffer.writeRawVarint32(val[i]);
}
}
}
//
// proto3 type: uint64
// java type: int
// signed/unsigned: unsigned
// encoding: varint
// wire type: WIRE_TYPE_VARINT
//
/**
* Write a single proto "uint64" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeUInt64(long fieldId, long val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_UINT64);
writeUInt64Impl(id, val);
}
private void writeUInt64Impl(int id, long val) {
if (val != 0) {
writeTag(id, WIRE_TYPE_VARINT);
mBuffer.writeRawVarint64(val);
}
}
/**
* Write a single proto "uint64" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeRepeatedUInt64(long fieldId, long val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_UINT64);
writeRepeatedUInt64Impl(id, val);
}
private void writeRepeatedUInt64Impl(int id, long val) {
writeTag(id, WIRE_TYPE_VARINT);
mBuffer.writeRawVarint64(val);
}
/**
* Write a single proto "uint64" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writePackedUInt64(long fieldId, long[] val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_PACKED | FIELD_TYPE_UINT64);
final int N = val != null ? val.length : 0;
if (N > 0) {
int size = 0;
for (int i=0; i<N; i++) {
size += EncodedBuffer.getRawVarint64Size(val[i]);
}
writeKnownLengthHeader(id, size);
for (int i=0; i<N; i++) {
mBuffer.writeRawVarint64(val[i]);
}
}
}
//
// proto3 type: sint32
// java type: int
// signed/unsigned: signed
// encoding: zig-zag
// wire type: WIRE_TYPE_VARINT
//
/**
* Write a single proto "sint32" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeSInt32(long fieldId, int val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_SINT32);
writeSInt32Impl(id, val);
}
private void writeSInt32Impl(int id, int val) {
if (val != 0) {
writeTag(id, WIRE_TYPE_VARINT);
mBuffer.writeRawZigZag32(val);
}
}
/**
* Write a single repeated proto "sint32" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeRepeatedSInt32(long fieldId, int val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_SINT32);
writeRepeatedSInt32Impl(id, val);
}
private void writeRepeatedSInt32Impl(int id, int val) {
writeTag(id, WIRE_TYPE_VARINT);
mBuffer.writeRawZigZag32(val);
}
/**
* Write a list of packed proto "sint32" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writePackedSInt32(long fieldId, int[] val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_PACKED | FIELD_TYPE_SINT32);
final int N = val != null ? val.length : 0;
if (N > 0) {
int size = 0;
for (int i=0; i<N; i++) {
size += EncodedBuffer.getRawZigZag32Size(val[i]);
}
writeKnownLengthHeader(id, size);
for (int i=0; i<N; i++) {
mBuffer.writeRawZigZag32(val[i]);
}
}
}
//
// proto3 type: sint64
// java type: int
// signed/unsigned: signed
// encoding: zig-zag
// wire type: WIRE_TYPE_VARINT
//
/**
* Write a single proto "sint64" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeSInt64(long fieldId, long val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_SINT64);
writeSInt64Impl(id, val);
}
private void writeSInt64Impl(int id, long val) {
if (val != 0) {
writeTag(id, WIRE_TYPE_VARINT);
mBuffer.writeRawZigZag64(val);
}
}
/**
* Write a single repeated proto "sint64" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeRepeatedSInt64(long fieldId, long val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_SINT64);
writeRepeatedSInt64Impl(id, val);
}
private void writeRepeatedSInt64Impl(int id, long val) {
writeTag(id, WIRE_TYPE_VARINT);
mBuffer.writeRawZigZag64(val);
}
/**
* Write a list of packed proto "sint64" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writePackedSInt64(long fieldId, long[] val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_PACKED | FIELD_TYPE_SINT64);
final int N = val != null ? val.length : 0;
if (N > 0) {
int size = 0;
for (int i=0; i<N; i++) {
size += EncodedBuffer.getRawZigZag64Size(val[i]);
}
writeKnownLengthHeader(id, size);
for (int i=0; i<N; i++) {
mBuffer.writeRawZigZag64(val[i]);
}
}
}
//
// proto3 type: fixed32
// java type: int
// encoding: little endian
// wire type: WIRE_TYPE_FIXED32
//
/**
* Write a single proto "fixed32" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeFixed32(long fieldId, int val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_FIXED32);
writeFixed32Impl(id, val);
}
private void writeFixed32Impl(int id, int val) {
if (val != 0) {
writeTag(id, WIRE_TYPE_FIXED32);
mBuffer.writeRawFixed32(val);
}
}
/**
* Write a single repeated proto "fixed32" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeRepeatedFixed32(long fieldId, int val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_FIXED32);
writeRepeatedFixed32Impl(id, val);
}
private void writeRepeatedFixed32Impl(int id, int val) {
writeTag(id, WIRE_TYPE_FIXED32);
mBuffer.writeRawFixed32(val);
}
/**
* Write a list of packed proto "fixed32" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writePackedFixed32(long fieldId, int[] val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_PACKED | FIELD_TYPE_FIXED32);
final int N = val != null ? val.length : 0;
if (N > 0) {
writeKnownLengthHeader(id, N * 4);
for (int i=0; i<N; i++) {
mBuffer.writeRawFixed32(val[i]);
}
}
}
//
// proto3 type: fixed64
// java type: long
// encoding: fixed64
// wire type: WIRE_TYPE_FIXED64
//
/**
* Write a single proto "fixed64" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeFixed64(long fieldId, long val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_FIXED64);
writeFixed64Impl(id, val);
}
private void writeFixed64Impl(int id, long val) {
if (val != 0) {
writeTag(id, WIRE_TYPE_FIXED64);
mBuffer.writeRawFixed64(val);
}
}
/**
* Write a single repeated proto "fixed64" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeRepeatedFixed64(long fieldId, long val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_FIXED64);
writeRepeatedFixed64Impl(id, val);
}
private void writeRepeatedFixed64Impl(int id, long val) {
writeTag(id, WIRE_TYPE_FIXED64);
mBuffer.writeRawFixed64(val);
}
/**
* Write a list of packed proto "fixed64" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writePackedFixed64(long fieldId, long[] val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_PACKED | FIELD_TYPE_FIXED64);
final int N = val != null ? val.length : 0;
if (N > 0) {
writeKnownLengthHeader(id, N * 8);
for (int i=0; i<N; i++) {
mBuffer.writeRawFixed64(val[i]);
}
}
}
//
// proto3 type: sfixed32
// java type: int
// encoding: little endian
// wire type: WIRE_TYPE_FIXED32
//
/**
* Write a single proto "sfixed32" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeSFixed32(long fieldId, int val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_SFIXED32);
writeSFixed32Impl(id, val);
}
private void writeSFixed32Impl(int id, int val) {
if (val != 0) {
writeTag(id, WIRE_TYPE_FIXED32);
mBuffer.writeRawFixed32(val);
}
}
/**
* Write a single repeated proto "sfixed32" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeRepeatedSFixed32(long fieldId, int val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_SFIXED32);
writeRepeatedSFixed32Impl(id, val);
}
private void writeRepeatedSFixed32Impl(int id, int val) {
writeTag(id, WIRE_TYPE_FIXED32);
mBuffer.writeRawFixed32(val);
}
/**
* Write a list of packed proto "sfixed32" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writePackedSFixed32(long fieldId, int[] val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_PACKED | FIELD_TYPE_SFIXED32);
final int N = val != null ? val.length : 0;
if (N > 0) {
writeKnownLengthHeader(id, N * 4);
for (int i=0; i<N; i++) {
mBuffer.writeRawFixed32(val[i]);
}
}
}
//
// proto3 type: sfixed64
// java type: long
// encoding: little endian
// wire type: WIRE_TYPE_FIXED64
//
/**
* Write a single proto "sfixed64" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeSFixed64(long fieldId, long val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_SFIXED64);
writeSFixed64Impl(id, val);
}
private void writeSFixed64Impl(int id, long val) {
if (val != 0) {
writeTag(id, WIRE_TYPE_FIXED64);
mBuffer.writeRawFixed64(val);
}
}
/**
* Write a single repeated proto "sfixed64" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeRepeatedSFixed64(long fieldId, long val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_SFIXED64);
writeRepeatedSFixed64Impl(id, val);
}
private void writeRepeatedSFixed64Impl(int id, long val) {
writeTag(id, WIRE_TYPE_FIXED64);
mBuffer.writeRawFixed64(val);
}
/**
* Write a list of packed proto "sfixed64" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writePackedSFixed64(long fieldId, long[] val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_PACKED | FIELD_TYPE_SFIXED64);
final int N = val != null ? val.length : 0;
if (N > 0) {
writeKnownLengthHeader(id, N * 8);
for (int i=0; i<N; i++) {
mBuffer.writeRawFixed64(val[i]);
}
}
}
//
// proto3 type: bool
// java type: boolean
// encoding: varint
// wire type: WIRE_TYPE_VARINT
//
/**
* Write a single proto "bool" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeBool(long fieldId, boolean val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_BOOL);
writeBoolImpl(id, val);
}
private void writeBoolImpl(int id, boolean val) {
if (val) {
writeTag(id, WIRE_TYPE_VARINT);
// 0 and 1 are the same as their varint counterparts
mBuffer.writeRawByte((byte)1);
}
}
/**
* Write a single repeated proto "bool" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeRepeatedBool(long fieldId, boolean val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_BOOL);
writeRepeatedBoolImpl(id, val);
}
private void writeRepeatedBoolImpl(int id, boolean val) {
writeTag(id, WIRE_TYPE_VARINT);
mBuffer.writeRawByte((byte)(val ? 1 : 0));
}
/**
* Write a list of packed proto "bool" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writePackedBool(long fieldId, boolean[] val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_PACKED | FIELD_TYPE_BOOL);
final int N = val != null ? val.length : 0;
if (N > 0) {
// Write the header
writeKnownLengthHeader(id, N);
// Write the data
for (int i=0; i<N; i++) {
// 0 and 1 are the same as their varint counterparts
mBuffer.writeRawByte((byte)(val[i] ? 1 : 0));
}
}
}
//
// proto3 type: string
// java type: String
// encoding: utf-8
// wire type: WIRE_TYPE_LENGTH_DELIMITED
//
/**
* Write a single proto "string" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeString(long fieldId, String val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_STRING);
writeStringImpl(id, val);
}
private void writeStringImpl(int id, String val) {
if (val != null && val.length() > 0) {
writeUtf8String(id, val);
}
}
/**
* Write a single repeated proto "string" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeRepeatedString(long fieldId, String val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_STRING);
writeRepeatedStringImpl(id, val);
}
private void writeRepeatedStringImpl(int id, String val) {
if (val == null || val.length() == 0) {
writeKnownLengthHeader(id, 0);
} else {
writeUtf8String(id, val);
}
}
/**
* Write a list of packed proto "string" type field value.
*/
private void writeUtf8String(int id, String val) {
// TODO: Is it worth converting by hand in order to not allocate?
try {
final byte[] buf = val.getBytes("UTF-8");
writeKnownLengthHeader(id, buf.length);
mBuffer.writeRawBuffer(buf);
} catch (UnsupportedEncodingException ex) {
throw new RuntimeException("not possible");
}
}
//
// proto3 type: bytes
// java type: byte[]
// encoding: varint
// wire type: WIRE_TYPE_VARINT
//
/**
* Write a single proto "bytes" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeBytes(long fieldId, byte[] val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_BYTES);
writeBytesImpl(id, val);
}
private void writeBytesImpl(int id, byte[] val) {
if (val != null && val.length > 0) {
writeKnownLengthHeader(id, val.length);
mBuffer.writeRawBuffer(val);
}
}
/**
* Write a single repeated proto "bytes" type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeRepeatedBytes(long fieldId, byte[] val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_BYTES);
writeRepeatedBytesImpl(id, val);
}
private void writeRepeatedBytesImpl(int id, byte[] val) {
writeKnownLengthHeader(id, val == null ? 0 : val.length);
mBuffer.writeRawBuffer(val);
}
//
// proto3 type: enum
// java type: int
// signed/unsigned: unsigned
// encoding: varint
// wire type: WIRE_TYPE_VARINT
//
/**
* Write a single proto enum type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeEnum(long fieldId, int val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_ENUM);
writeEnumImpl(id, val);
}
private void writeEnumImpl(int id, int val) {
if (val != 0) {
writeTag(id, WIRE_TYPE_VARINT);
writeUnsignedVarintFromSignedInt(val);
}
}
/**
* Write a single repeated proto enum type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeRepeatedEnum(long fieldId, int val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_ENUM);
writeRepeatedEnumImpl(id, val);
}
private void writeRepeatedEnumImpl(int id, int val) {
writeTag(id, WIRE_TYPE_VARINT);
writeUnsignedVarintFromSignedInt(val);
}
/**
* Write a list of packed proto enum type field value.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writePackedEnum(long fieldId, int[] val) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_PACKED | FIELD_TYPE_ENUM);
final int N = val != null ? val.length : 0;
if (N > 0) {
int size = 0;
for (int i=0; i<N; i++) {
final int v = val[i];
size += v >= 0 ? EncodedBuffer.getRawVarint32Size(v) : 10;
}
writeKnownLengthHeader(id, size);
for (int i=0; i<N; i++) {
writeUnsignedVarintFromSignedInt(val[i]);
}
}
}
//
// Child objects
//
/**
* Make a token.
* Bits 61-63 - tag size (So we can go backwards later if the object had not data)
* - 3 bits, max value 7, max value needed 5
* Bit 60 - true if the object is repeated (lets us require endObject or endRepeatedObject)
* Bits 59-51 - depth (For error checking)
* - 9 bits, max value 512, when checking, value is masked (if we really
* are more than 512 levels deep)
* Bits 32-50 - objectId (For error checking)
* - 19 bits, max value 524,288. that's a lot of objects. IDs will wrap
* because of the overflow, and only the tokens are compared.
* Bits 0-31 - offset of the first size field in the buffer.
*/
// VisibleForTesting
public static long makeToken(int tagSize, boolean repeated, int depth, int objectId,
int sizePos) {
return ((0x07L & (long)tagSize) << 61)
| (repeated ? (1L << 60) : 0)
| (0x01ffL & (long)depth) << 51
| (0x07ffffL & (long)objectId) << 32
| (0x0ffffffffL & (long)sizePos);
}
/**
* Get the encoded tag size from the token.
*/
public static int getTagSizeFromToken(long token) {
return (int)(0x7 & (token >> 61));
}
/**
* Get whether this is a call to startObject (false) or startRepeatedObject (true).
*/
public static boolean getRepeatedFromToken(long token) {
return (0x1 & (token >> 60)) != 0;
}
/**
* Get the nesting depth of startObject calls from the token.
*/
public static int getDepthFromToken(long token) {
return (int)(0x01ff & (token >> 51));
}
/**
* Get the object ID from the token. The object ID is a serial number for the
* startObject calls that have happened on this object. The values are truncated
* to 9 bits, but that is sufficient for error checking.
*/
public static int getObjectIdFromToken(long token) {
return (int)(0x07ffff & (token >> 32));
}
/**
* Get the location of the childRawSize (the first 32 bit size field) in this object.
*/
public static int getSizePosFromToken(long token) {
return (int)token;
}
/**
* Convert the object ID to the ordinal value -- the n-th call to startObject.
* The object IDs start at -1 and count backwards, so that the value is unlikely
* to alias with an actual size field that had been written.
*/
public static int convertObjectIdToOrdinal(int objectId) {
return (-1 & 0x07ffff) - objectId;
}
/**
* Return a debugging string of a token.
*/
public static String token2String(long token) {
if (token == 0L) {
return "Token(0)";
} else {
return "Token(val=0x" + Long.toHexString(token)
+ " depth=" + getDepthFromToken(token)
+ " object=" + convertObjectIdToOrdinal(getObjectIdFromToken(token))
+ " tagSize=" + getTagSizeFromToken(token)
+ " sizePos=" + getSizePosFromToken(token)
+ ')';
}
}
/**
* Start a child object.
*
* Returns a token which should be passed to endObject. Calls to endObject must be
* nested properly.
*
* @deprecated Use #start() instead.
*/
@Deprecated
public long startObject(long fieldId) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_OBJECT);
return startObjectImpl(id, false);
}
/**
* End a child object. Pass in the token from the correspoinding startObject call.
*
* @deprecated Use #end() instead.
*/
@Deprecated
public void endObject(long token) {
assertNotCompacted();
endObjectImpl(token, false);
}
/**
* Start a repeated child object.
*
* Returns a token which should be passed to endObject. Calls to endObject must be
* nested properly.
*
* @deprecated Use #start() instead.
*/
@Deprecated
public long startRepeatedObject(long fieldId) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_OBJECT);
return startObjectImpl(id, true);
}
/**
* End a child object. Pass in the token from the correspoinding startRepeatedObject call.
*
* @deprecated Use #end() instead.
*/
@Deprecated
public void endRepeatedObject(long token) {
assertNotCompacted();
endObjectImpl(token, true);
}
/**
* Common implementation of startObject and startRepeatedObject.
*/
private long startObjectImpl(final int id, boolean repeated) {
writeTag(id, WIRE_TYPE_LENGTH_DELIMITED);
final int sizePos = mBuffer.getWritePos();
mDepth++;
mNextObjectId--;
// Write the previous token, giving us a stack of expected tokens.
// After endObject returns, the first fixed32 becomeschildRawSize (set in endObject)
// and the second one becomes childEncodedSize (set in editEncodedSize).
mBuffer.writeRawFixed32((int)(mExpectedObjectToken >> 32));
mBuffer.writeRawFixed32((int)mExpectedObjectToken);
long old = mExpectedObjectToken;
mExpectedObjectToken = makeToken(getTagSize(id), repeated, mDepth, mNextObjectId, sizePos);
return mExpectedObjectToken;
}
/**
* Common implementation of endObject and endRepeatedObject.
*/
private void endObjectImpl(long token, boolean repeated) {
// The upper 32 bits of the token is the depth of startObject /
// endObject calls. We could get aritrarily sophisticated, but
// that's enough to prevent the common error of missing an
// endObject somewhere.
// The lower 32 bits of the token is the offset in the buffer
// at which to write the size.
final int depth = getDepthFromToken(token);
final boolean expectedRepeated = getRepeatedFromToken(token);
final int sizePos = getSizePosFromToken(token);
final int childRawSize = mBuffer.getWritePos() - sizePos - 8;
if (repeated != expectedRepeated) {
if (repeated) {
throw new IllegalArgumentException("endRepeatedObject called where endObject should"
+ " have been");
} else {
throw new IllegalArgumentException("endObject called where endRepeatedObject should"
+ " have been");
}
}
// Check that we're getting the token and depth that we are expecting.
if ((mDepth & 0x01ff) != depth || mExpectedObjectToken != token) {
// This text of exception is united tested. That test also implicity checks
// that we're tracking the objectIds and depths correctly.
throw new IllegalArgumentException("Mismatched startObject/endObject calls."
+ " Current depth " + mDepth
+ " token=" + token2String(token)
+ " expectedToken=" + token2String(mExpectedObjectToken));
}
// Get the next expected token that we stashed away in the buffer.
mExpectedObjectToken = (((long)mBuffer.getRawFixed32At(sizePos)) << 32)
| (0x0ffffffffL & (long)mBuffer.getRawFixed32At(sizePos+4));
mDepth--;
if (childRawSize > 0) {
mBuffer.editRawFixed32(sizePos, -childRawSize);
mBuffer.editRawFixed32(sizePos+4, -1);
} else if (repeated) {
mBuffer.editRawFixed32(sizePos, 0);
mBuffer.editRawFixed32(sizePos+4, 0);
} else {
// The object has no data. Don't include it.
mBuffer.rewindWriteTo(sizePos - getTagSizeFromToken(token));
}
}
/**
* Write an object that has already been flattend.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeObject(long fieldId, byte[] value) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_SINGLE | FIELD_TYPE_OBJECT);
writeObjectImpl(id, value);
}
void writeObjectImpl(int id, byte[] value) {
if (value != null && value.length != 0) {
writeKnownLengthHeader(id, value.length);
mBuffer.writeRawBuffer(value);
}
}
/**
* Write an object that has already been flattend.
*
* @deprecated Use #write instead.
*/
@Deprecated
public void writeRepeatedObject(long fieldId, byte[] value) {
assertNotCompacted();
final int id = checkFieldId(fieldId, FIELD_COUNT_REPEATED | FIELD_TYPE_OBJECT);
writeRepeatedObjectImpl(id, value);
}
void writeRepeatedObjectImpl(int id, byte[] value) {
writeKnownLengthHeader(id, value == null ? 0 : value.length);
mBuffer.writeRawBuffer(value);
}
//
// Tags
//
/**
* Combine a fieldId (the field keys in the proto file) and the field flags.
* Mostly useful for testing because the generated code contains the fieldId
* constants.
*/
public static long makeFieldId(int id, long fieldFlags) {
return fieldFlags | (((long)id) & 0x0ffffffffL);
}
/**
* Validates that the fieldId providied is of the type and count from expectedType.
*
* The type must match exactly to pass this check.
*
* The count must match according to this truth table to pass the check:
*
* expectedFlags
* UNKNOWN SINGLE REPEATED PACKED
* fieldId
* UNKNOWN true false false false
* SINGLE x true false false
* REPEATED x false true false
* PACKED x false true true
*
* @throws IllegalArgumentException if it is not.
*
* @return The raw ID of that field.
*/
public static int checkFieldId(long fieldId, long expectedFlags) {
final long fieldCount = fieldId & FIELD_COUNT_MASK;
final long fieldType = fieldId & FIELD_TYPE_MASK;
final long expectedCount = expectedFlags & FIELD_COUNT_MASK;
final long expectedType = expectedFlags & FIELD_TYPE_MASK;
if (((int)fieldId) == 0) {
throw new IllegalArgumentException("Invalid proto field " + (int)fieldId
+ " fieldId=" + Long.toHexString(fieldId));
}
if (fieldType != expectedType
|| !((fieldCount == expectedCount)
|| (fieldCount == FIELD_COUNT_PACKED
&& expectedCount == FIELD_COUNT_REPEATED))) {
final String countString = getFieldCountString(fieldCount);
final String typeString = getFieldTypeString(fieldType);
if (typeString != null && countString != null) {
final StringBuilder sb = new StringBuilder();
if (expectedType == FIELD_TYPE_OBJECT) {
sb.append("start");
} else {
sb.append("write");
}
sb.append(getFieldCountString(expectedCount));
sb.append(getFieldTypeString(expectedType));
sb.append(" called for field ");
sb.append((int)fieldId);
sb.append(" which should be used with ");
if (fieldType == FIELD_TYPE_OBJECT) {
sb.append("start");
} else {
sb.append("write");
}
sb.append(countString);
sb.append(typeString);
if (fieldCount == FIELD_COUNT_PACKED) {
sb.append(" or writeRepeated");
sb.append(typeString);
}
sb.append('.');
throw new IllegalArgumentException(sb.toString());
} else {
final StringBuilder sb = new StringBuilder();
if (expectedType == FIELD_TYPE_OBJECT) {
sb.append("start");
} else {
sb.append("write");
}
sb.append(getFieldCountString(expectedCount));
sb.append(getFieldTypeString(expectedType));
sb.append(" called with an invalid fieldId: 0x");
sb.append(Long.toHexString(fieldId));
sb.append(". The proto field ID might be ");
sb.append((int)fieldId);
sb.append('.');
throw new IllegalArgumentException(sb.toString());
}
}
return (int)fieldId;
}
/**
* Get the developer-usable name of a field type.
*/
private static String getFieldTypeString(long fieldType) {
int index = ((int)((fieldType & FIELD_TYPE_MASK) >>> FIELD_TYPE_SHIFT)) - 1;
if (index >= 0 && index < FIELD_TYPE_NAMES.length) {
return FIELD_TYPE_NAMES[index];
} else {
return null;
}
}
/**
* Get the developer-usable name of a field count.
*/
private static String getFieldCountString(long fieldCount) {
if (fieldCount == FIELD_COUNT_SINGLE) {
return "";
} else if (fieldCount == FIELD_COUNT_REPEATED) {
return "Repeated";
} else if (fieldCount == FIELD_COUNT_PACKED) {
return "Packed";
} else {
return null;
}
}
/**
* Get a debug string for a fieldId.
*/
private String getFieldIdString(long fieldId) {
final long fieldCount = fieldId & FIELD_COUNT_MASK;
String countString = getFieldCountString(fieldCount);
if (countString == null) {
countString = "fieldCount=" + fieldCount;
}
final long fieldType = fieldId & FIELD_TYPE_MASK;
String typeString = getFieldTypeString(fieldType);
if (typeString == null) {
typeString = "fieldType=" + fieldType;
}
return fieldCount + " " + typeString + " tag=" + ((int)fieldId)
+ " fieldId=0x" + Long.toHexString(fieldId);
}
/**
* Return how many bytes an encoded field tag will require.
*/
private static int getTagSize(int id) {
return EncodedBuffer.getRawVarint32Size(id << FIELD_ID_SHIFT);
}
/**
* Write a field tage to the stream.
*/
public void writeTag(int id, int wireType) {
mBuffer.writeRawVarint32((id << FIELD_ID_SHIFT) | wireType);
}
/**
* Write the header of a WIRE_TYPE_LENGTH_DELIMITED field for one where
* we know the size in advance and do not need to compute and compact.
*/
private void writeKnownLengthHeader(int id, int size) {
// Write the tag
writeTag(id, WIRE_TYPE_LENGTH_DELIMITED);
// Size will be compacted later, but we know the size, so write it,
// once for the rawSize and once for the encodedSize.
mBuffer.writeRawFixed32(size);
mBuffer.writeRawFixed32(size);
}
//
// Getting the buffer and compaction
//
/**
* Assert that the compact call has not already occured.
*
* TODO: Will change when we add the OutputStream version of ProtoOutputStream.
*/
private void assertNotCompacted() {
if (mCompacted) {
throw new IllegalArgumentException("write called after compact");
}
}
/**
* Finish the encoding of the data, and return a byte[] with
* the protobuf formatted data.
*
* After this call, do not call any of the write* functions. The
* behavior is undefined.
*/
public byte[] getBytes() {
compactIfNecessary();
return mBuffer.getBytes(mBuffer.getReadableSize());
}
/**
* If the buffer hasn't already had the nested object size fields compacted
* and turned into an actual protobuf format, then do so.
*/
private void compactIfNecessary() {
if (!mCompacted) {
if (mDepth != 0) {
throw new IllegalArgumentException("Trying to compact with " + mDepth
+ " missing calls to endObject");
}
// The buffer must be compacted.
mBuffer.startEditing();
final int readableSize = mBuffer.getReadableSize();
// Cache the sizes of the objects
editEncodedSize(readableSize);
// Re-write the buffer with the sizes as proper varints instead
// of pairs of uint32s. We know this will always fit in the same
// buffer because the pair of uint32s is exactly 8 bytes long, and
// the single varint size will be no more than 5 bytes long.
mBuffer.rewindRead();
compactSizes(readableSize);
// If there is any data left over that wasn't copied yet, copy it.
if (mCopyBegin < readableSize) {
mBuffer.writeFromThisBuffer(mCopyBegin, readableSize - mCopyBegin);
}
// Set the new readableSize
mBuffer.startEditing();
// It's not valid to write to this object anymore. The write
// pointers are off, and then some of the data would be compacted
// and some not.
mCompacted = true;
}
}
/**
* First compaction pass. Iterate through the data, and fill in the
* nested object sizes so the next pass can compact them.
*/
private int editEncodedSize(int rawSize) {
int objectStart = mBuffer.getReadPos();
int objectEnd = objectStart + rawSize;
int encodedSize = 0;
int tagPos;
while ((tagPos = mBuffer.getReadPos()) < objectEnd) {
int tag = readRawTag();
encodedSize += EncodedBuffer.getRawVarint32Size(tag);
final int wireType = tag & WIRE_TYPE_MASK;
switch (wireType) {
case WIRE_TYPE_VARINT:
encodedSize++;
while ((mBuffer.readRawByte() & 0x80) != 0) {
encodedSize++;
}
break;
case WIRE_TYPE_FIXED64:
encodedSize += 8;
mBuffer.skipRead(8);
break;
case WIRE_TYPE_LENGTH_DELIMITED: {
// This object is not of a fixed-size type. So we need to figure
// out how big it should be.
final int childRawSize = mBuffer.readRawFixed32();
final int childEncodedSizePos = mBuffer.getReadPos();
int childEncodedSize = mBuffer.readRawFixed32();
if (childRawSize >= 0) {
// We know the size, just skip ahead.
if (childEncodedSize != childRawSize) {
throw new RuntimeException("Pre-computed size where the"
+ " precomputed size and the raw size in the buffer"
+ " don't match! childRawSize=" + childRawSize
+ " childEncodedSize=" + childEncodedSize
+ " childEncodedSizePos=" + childEncodedSizePos);
}
mBuffer.skipRead(childRawSize);
} else {
// We need to compute the size. Recurse.
childEncodedSize = editEncodedSize(-childRawSize);
mBuffer.editRawFixed32(childEncodedSizePos, childEncodedSize);
}
encodedSize += EncodedBuffer.getRawVarint32Size(childEncodedSize)
+ childEncodedSize;
break;
}
case WIRE_TYPE_START_GROUP:
case WIRE_TYPE_END_GROUP:
throw new RuntimeException("groups not supported at index " + tagPos);
case WIRE_TYPE_FIXED32:
encodedSize += 4;
mBuffer.skipRead(4);
break;
default:
throw new ProtoParseException("editEncodedSize Bad tag tag=0x"
+ Integer.toHexString(tag) + " wireType=" + wireType
+ " -- " + mBuffer.getDebugString());
}
}
return encodedSize;
}
/**
* Second compaction pass. Iterate through the data, and copy the data
* forward in the buffer, converting the pairs of uint32s into a single
* unsigned varint of the size.
*/
private void compactSizes(int rawSize) {
int objectStart = mBuffer.getReadPos();
int objectEnd = objectStart + rawSize;
int tagPos;
while ((tagPos = mBuffer.getReadPos()) < objectEnd) {
int tag = readRawTag();
// For all the non-length-delimited field types, just skip over them,
// and we'll just System.arraycopy it later, either in the case for
// WIRE_TYPE_LENGTH_DELIMITED or at the top of the stack in compactIfNecessary().
final int wireType = tag & WIRE_TYPE_MASK;
switch (wireType) {
case WIRE_TYPE_VARINT:
while ((mBuffer.readRawByte() & 0x80) != 0) { }
break;
case WIRE_TYPE_FIXED64:
mBuffer.skipRead(8);
break;
case WIRE_TYPE_LENGTH_DELIMITED: {
// Copy everything up to now, including the tag for this field.
mBuffer.writeFromThisBuffer(mCopyBegin, mBuffer.getReadPos() - mCopyBegin);
// Write the new size.
final int childRawSize = mBuffer.readRawFixed32();
final int childEncodedSize = mBuffer.readRawFixed32();
mBuffer.writeRawVarint32(childEncodedSize);
// Next time, start copying from here.
mCopyBegin = mBuffer.getReadPos();
if (childRawSize >= 0) {
// This is raw data, not an object. Skip ahead by the size.
// Recurse into the child
mBuffer.skipRead(childEncodedSize);
} else {
compactSizes(-childRawSize);
}
break;
// TODO: What does regular proto do if the object would be 0 size
// (e.g. if it is all default values).
}
case WIRE_TYPE_START_GROUP:
case WIRE_TYPE_END_GROUP:
throw new RuntimeException("groups not supported at index " + tagPos);
case WIRE_TYPE_FIXED32:
mBuffer.skipRead(4);
break;
default:
throw new ProtoParseException("compactSizes Bad tag tag=0x"
+ Integer.toHexString(tag) + " wireType=" + wireType
+ " -- " + mBuffer.getDebugString());
}
}
}
/**
* Write remaining data to the output stream. If there is no output stream,
* this function does nothing. Any currently open objects (i.e. ones that
* have not had endObject called for them will not be written). Whether this
* writes objects that are closed if there are remaining open objects is
* undefined (current implementation does not write it, future ones will).
* For now, can either call getBytes() or flush(), but not both.
*/
public void flush() {
if (mStream == null) {
return;
}
if (mDepth != 0) {
// TODO: The compacting code isn't ready yet to compact unless we're done.
// TODO: Fix that.
return;
}
if (mCompacted) {
// If we're compacted, we already wrote it finished.
return;
}
compactIfNecessary();
final byte[] data = mBuffer.getBytes(mBuffer.getReadableSize());
try {
mStream.write(data);
mStream.flush();
} catch (IOException ex) {
throw new RuntimeException("Error flushing proto to stream", ex);
}
}
/**
* Read a raw tag from the buffer.
*/
private int readRawTag() {
if (mBuffer.getReadPos() == mBuffer.getReadableSize()) {
return 0;
}
return (int)mBuffer.readRawUnsigned();
}
/**
* Dump debugging data about the buffers with the given log tag.
*/
public void dump(String tag) {
Log.d(tag, mBuffer.getDebugString());
mBuffer.dumpBuffers(tag);
}
}