// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
package com.google.protobuf;
import com.google.protobuf.
AbstractMessageLite.
Builder.
LimitedInputStream;
import java.io.
IOException;
import java.io.
InputStream;
import java.io.
OutputStream;
import java.util.
ArrayList;
import java.util.
Arrays;
import java.util.
Collections;
import java.util.
List;
import java.util.
ListIterator;
import java.util.
Map;
import java.util.
TreeMap;
/**
* {@code UnknownFieldSet} is used to keep track of fields which were seen when
* parsing a protocol message but whose field numbers or types are unrecognized.
* This most frequently occurs when new fields are added to a message type
* and then messages containing those fields are read by old software that was
* compiled before the new types were added.
*
* <p>Every {@link Message} contains an {@code UnknownFieldSet} (and every
* {@link Message.Builder} contains an {@link Builder}).
*
* <p>Most users will never need to use this class.
*
* @author kenton@google.com Kenton Varda
*/
public final class
UnknownFieldSet implements
MessageLite {
private
UnknownFieldSet() {
fields = null;
}
/** Create a new {@link Builder}. */
public static
Builder newBuilder() {
return
Builder.
create();
}
/**
* Create a new {@link Builder} and initialize it to be a copy
* of {@code copyFrom}.
*/
public static
Builder newBuilder(final
UnknownFieldSet copyFrom) {
return
newBuilder().
mergeFrom(
copyFrom);
}
/** Get an empty {@code UnknownFieldSet}. */
public static
UnknownFieldSet getDefaultInstance() {
return
defaultInstance;
}
@
Override
public
UnknownFieldSet getDefaultInstanceForType() {
return
defaultInstance;
}
private static final
UnknownFieldSet defaultInstance =
new
UnknownFieldSet(
Collections.<
Integer,
Field>
emptyMap(),
Collections.<
Integer,
Field>
emptyMap());
/**
* Construct an {@code UnknownFieldSet} around the given map. The map is
* expected to be immutable.
*/
UnknownFieldSet(final
Map<
Integer,
Field>
fields,
final
Map<
Integer,
Field>
fieldsDescending) {
this.
fields =
fields;
}
private final
Map<
Integer,
Field>
fields;
@
Override
public boolean
equals(final
Object other) {
if (this ==
other) {
return true;
}
return (
other instanceof
UnknownFieldSet) &&
fields.
equals(((
UnknownFieldSet)
other).
fields);
}
@
Override
public int
hashCode() {
return
fields.
hashCode();
}
/** Get a map of fields in the set by number. */
public
Map<
Integer,
Field>
asMap() {
return
fields;
}
/** Check if the given field number is present in the set. */
public boolean
hasField(final int
number) {
return
fields.
containsKey(
number);
}
/**
* Get a field by number. Returns an empty field if not present. Never
* returns {@code null}.
*/
public
Field getField(final int
number) {
final
Field result =
fields.
get(
number);
return (
result == null) ?
Field.
getDefaultInstance() :
result;
}
/** Serializes the set and writes it to {@code output}. */
@
Override
public void
writeTo(final
CodedOutputStream output) throws
IOException {
for (final
Map.
Entry<
Integer,
Field>
entry :
fields.
entrySet()) {
Field field =
entry.
getValue();
field.
writeTo(
entry.
getKey(),
output);
}
}
/**
* Converts the set to a string in protocol buffer text format. This is
* just a trivial wrapper around
* {@link TextFormat#printToString(UnknownFieldSet)}.
*/
@
Override
public
String toString() {
return
TextFormat.
printToString(this);
}
/**
* Serializes the message to a {@code ByteString} and returns it. This is
* just a trivial wrapper around {@link #writeTo(CodedOutputStream)}.
*/
@
Override
public
ByteString toByteString() {
try {
final
ByteString.
CodedBuilder out =
ByteString.
newCodedBuilder(
getSerializedSize());
writeTo(
out.
getCodedOutput());
return
out.
build();
} catch (final
IOException e) {
throw new
RuntimeException(
"Serializing to a ByteString threw an IOException (should " +
"never happen).",
e);
}
}
/**
* Serializes the message to a {@code byte} array and returns it. This is
* just a trivial wrapper around {@link #writeTo(CodedOutputStream)}.
*/
@
Override
public byte[]
toByteArray() {
try {
final byte[]
result = new byte[
getSerializedSize()];
final
CodedOutputStream output =
CodedOutputStream.
newInstance(
result);
writeTo(
output);
output.
checkNoSpaceLeft();
return
result;
} catch (final
IOException e) {
throw new
RuntimeException(
"Serializing to a byte array threw an IOException " +
"(should never happen).",
e);
}
}
/**
* Serializes the message and writes it to {@code output}. This is just a
* trivial wrapper around {@link #writeTo(CodedOutputStream)}.
*/
@
Override
public void
writeTo(final
OutputStream output) throws
IOException {
final
CodedOutputStream codedOutput =
CodedOutputStream.
newInstance(
output);
writeTo(
codedOutput);
codedOutput.
flush();
}
@
Override
public void
writeDelimitedTo(
OutputStream output) throws
IOException {
final
CodedOutputStream codedOutput =
CodedOutputStream.
newInstance(
output);
codedOutput.
writeRawVarint32(
getSerializedSize());
writeTo(
codedOutput);
codedOutput.
flush();
}
/** Get the number of bytes required to encode this set. */
@
Override
public int
getSerializedSize() {
int
result = 0;
for (final
Map.
Entry<
Integer,
Field>
entry :
fields.
entrySet()) {
result +=
entry.
getValue().
getSerializedSize(
entry.
getKey());
}
return
result;
}
/**
* Serializes the set and writes it to {@code output} using
* {@code MessageSet} wire format.
*/
public void
writeAsMessageSetTo(final
CodedOutputStream output)
throws
IOException {
for (final
Map.
Entry<
Integer,
Field>
entry :
fields.
entrySet()) {
entry.
getValue().
writeAsMessageSetExtensionTo(
entry.
getKey(),
output);
}
}
/** Get the number of bytes required to encode this set using {@code MessageSet} wire format. */
public int
getSerializedSizeAsMessageSet() {
int
result = 0;
for (final
Map.
Entry<
Integer,
Field>
entry :
fields.
entrySet()) {
result +=
entry.
getValue().
getSerializedSizeAsMessageSetExtension(
entry.
getKey());
}
return
result;
}
@
Override
public boolean
isInitialized() {
// UnknownFieldSets do not have required fields, so they are always
// initialized.
return true;
}
/** Parse an {@code UnknownFieldSet} from the given input stream. */
public static
UnknownFieldSet parseFrom(final
CodedInputStream input)
throws
IOException {
return
newBuilder().
mergeFrom(
input).
build();
}
/** Parse {@code data} as an {@code UnknownFieldSet} and return it. */
public static
UnknownFieldSet parseFrom(final
ByteString data)
throws
InvalidProtocolBufferException {
return
newBuilder().
mergeFrom(
data).
build();
}
/** Parse {@code data} as an {@code UnknownFieldSet} and return it. */
public static
UnknownFieldSet parseFrom(final byte[]
data)
throws
InvalidProtocolBufferException {
return
newBuilder().
mergeFrom(
data).
build();
}
/** Parse an {@code UnknownFieldSet} from {@code input} and return it. */
public static
UnknownFieldSet parseFrom(final
InputStream input)
throws
IOException {
return
newBuilder().
mergeFrom(
input).
build();
}
@
Override
public
Builder newBuilderForType() {
return
newBuilder();
}
@
Override
public
Builder toBuilder() {
return
newBuilder().
mergeFrom(this);
}
/**
* Builder for {@link UnknownFieldSet}s.
*
* <p>Note that this class maintains {@link Field.Builder}s for all fields
* in the set. Thus, adding one element to an existing {@link Field} does not
* require making a copy. This is important for efficient parsing of
* unknown repeated fields. However, it implies that {@link Field}s cannot
* be constructed independently, nor can two {@link UnknownFieldSet}s share
* the same {@code Field} object.
*
* <p>Use {@link UnknownFieldSet#newBuilder()} to construct a {@code Builder}.
*/
public static final class
Builder implements
MessageLite.
Builder {
// This constructor should never be called directly (except from 'create').
private
Builder() {}
private
Map<
Integer,
Field>
fields;
// Optimization: We keep around a builder for the last field that was
// modified so that we can efficiently add to it multiple times in a
// row (important when parsing an unknown repeated field).
private int
lastFieldNumber;
private
Field.
Builder lastField;
private static
Builder create() {
Builder builder = new
Builder();
builder.
reinitialize();
return
builder;
}
/**
* Get a field builder for the given field number which includes any
* values that already exist.
*/
private
Field.
Builder getFieldBuilder(final int
number) {
if (
lastField != null) {
if (
number ==
lastFieldNumber) {
return
lastField;
}
// Note: addField() will reset lastField and lastFieldNumber.
addField(
lastFieldNumber,
lastField.
build());
}
if (
number == 0) {
return null;
} else {
final
Field existing =
fields.
get(
number);
lastFieldNumber =
number;
lastField =
Field.
newBuilder();
if (
existing != null) {
lastField.
mergeFrom(
existing);
}
return
lastField;
}
}
/**
* Build the {@link UnknownFieldSet} and return it.
*
* <p>Once {@code build()} has been called, the {@code Builder} will no
* longer be usable. Calling any method after {@code build()} will result
* in undefined behavior and can cause a {@code NullPointerException} to be
* thrown.
*/
@
Override
public
UnknownFieldSet build() {
getFieldBuilder(0); // Force lastField to be built.
final
UnknownFieldSet result;
if (
fields.
isEmpty()) {
result =
getDefaultInstance();
} else {
Map<
Integer,
Field>
descendingFields = null;
result = new
UnknownFieldSet(
Collections.
unmodifiableMap(
fields),
descendingFields);
}
fields = null;
return
result;
}
@
Override
public
UnknownFieldSet buildPartial() {
// No required fields, so this is the same as build().
return
build();
}
@
Override
public
Builder clone() {
getFieldBuilder(0); // Force lastField to be built.
Map<
Integer,
Field>
descendingFields = null;
return
UnknownFieldSet.
newBuilder().
mergeFrom(
new
UnknownFieldSet(
fields,
descendingFields));
}
@
Override
public
UnknownFieldSet getDefaultInstanceForType() {
return
UnknownFieldSet.
getDefaultInstance();
}
private void
reinitialize() {
fields =
Collections.
emptyMap();
lastFieldNumber = 0;
lastField = null;
}
/** Reset the builder to an empty set. */
@
Override
public
Builder clear() {
reinitialize();
return this;
}
/** Clear fields from the set with a given field number. */
public
Builder clearField(final int
number) {
if (
number == 0) {
throw new
IllegalArgumentException("Zero is not a valid field number.");
}
if (
lastField != null &&
lastFieldNumber ==
number) {
// Discard this.
lastField = null;
lastFieldNumber = 0;
}
if (
fields.
containsKey(
number)) {
fields.
remove(
number);
}
return this;
}
/**
* Merge the fields from {@code other} into this set. If a field number
* exists in both sets, {@code other}'s values for that field will be
* appended to the values in this set.
*/
public
Builder mergeFrom(final
UnknownFieldSet other) {
if (
other !=
getDefaultInstance()) {
for (final
Map.
Entry<
Integer,
Field>
entry :
other.
fields.
entrySet()) {
mergeField(
entry.
getKey(),
entry.
getValue());
}
}
return this;
}
/**
* Add a field to the {@code UnknownFieldSet}. If a field with the same
* number already exists, the two are merged.
*/
public
Builder mergeField(final int
number, final
Field field) {
if (
number == 0) {
throw new
IllegalArgumentException("Zero is not a valid field number.");
}
if (
hasField(
number)) {
getFieldBuilder(
number).
mergeFrom(
field);
} else {
// Optimization: We could call getFieldBuilder(number).mergeFrom(field)
// in this case, but that would create a copy of the Field object.
// We'd rather reuse the one passed to us, so call addField() instead.
addField(
number,
field);
}
return this;
}
/**
* Convenience method for merging a new field containing a single varint
* value. This is used in particular when an unknown enum value is
* encountered.
*/
public
Builder mergeVarintField(final int
number, final int
value) {
if (
number == 0) {
throw new
IllegalArgumentException("Zero is not a valid field number.");
}
getFieldBuilder(
number).
addVarint(
value);
return this;
}
/**
* Convenience method for merging a length-delimited field.
*
* <p>For use by generated code only.
*/
public
Builder mergeLengthDelimitedField(
final int
number, final
ByteString value) {
if (
number == 0) {
throw new
IllegalArgumentException("Zero is not a valid field number.");
}
getFieldBuilder(
number).
addLengthDelimited(
value);
return this;
}
/** Check if the given field number is present in the set. */
public boolean
hasField(final int
number) {
if (
number == 0) {
throw new
IllegalArgumentException("Zero is not a valid field number.");
}
return
number ==
lastFieldNumber ||
fields.
containsKey(
number);
}
/**
* Add a field to the {@code UnknownFieldSet}. If a field with the same
* number already exists, it is removed.
*/
public
Builder addField(final int
number, final
Field field) {
if (
number == 0) {
throw new
IllegalArgumentException("Zero is not a valid field number.");
}
if (
lastField != null &&
lastFieldNumber ==
number) {
// Discard this.
lastField = null;
lastFieldNumber = 0;
}
if (
fields.
isEmpty()) {
fields = new
TreeMap<
Integer,
Field>();
}
fields.
put(
number,
field);
return this;
}
/**
* Get all present {@code Field}s as an immutable {@code Map}. If more
* fields are added, the changes may or may not be reflected in this map.
*/
public
Map<
Integer,
Field>
asMap() {
getFieldBuilder(0); // Force lastField to be built.
return
Collections.
unmodifiableMap(
fields);
}
/**
* Parse an entire message from {@code input} and merge its fields into
* this set.
*/
@
Override
public
Builder mergeFrom(final
CodedInputStream input) throws
IOException {
while (true) {
final int
tag =
input.
readTag();
if (
tag == 0 || !
mergeFieldFrom(
tag,
input)) {
break;
}
}
return this;
}
/**
* Parse a single field from {@code input} and merge it into this set.
* @param tag The field's tag number, which was already parsed.
* @return {@code false} if the tag is an end group tag.
*/
public boolean
mergeFieldFrom(final int
tag, final
CodedInputStream input)
throws
IOException {
final int
number =
WireFormat.
getTagFieldNumber(
tag);
switch (
WireFormat.
getTagWireType(
tag)) {
case
WireFormat.
WIRETYPE_VARINT:
getFieldBuilder(
number).
addVarint(
input.
readInt64());
return true;
case
WireFormat.
WIRETYPE_FIXED64:
getFieldBuilder(
number).
addFixed64(
input.
readFixed64());
return true;
case
WireFormat.
WIRETYPE_LENGTH_DELIMITED:
getFieldBuilder(
number).
addLengthDelimited(
input.
readBytes());
return true;
case
WireFormat.
WIRETYPE_START_GROUP:
final
Builder subBuilder =
newBuilder();
input.
readGroup(
number,
subBuilder,
ExtensionRegistry.
getEmptyRegistry());
getFieldBuilder(
number).
addGroup(
subBuilder.
build());
return true;
case
WireFormat.
WIRETYPE_END_GROUP:
return false;
case
WireFormat.
WIRETYPE_FIXED32:
getFieldBuilder(
number).
addFixed32(
input.
readFixed32());
return true;
default:
throw
InvalidProtocolBufferException.
invalidWireType();
}
}
/**
* Parse {@code data} as an {@code UnknownFieldSet} and merge it with the
* set being built. This is just a small wrapper around
* {@link #mergeFrom(CodedInputStream)}.
*/
@
Override
public
Builder mergeFrom(final
ByteString data) throws
InvalidProtocolBufferException {
try {
final
CodedInputStream input =
data.
newCodedInput();
mergeFrom(
input);
input.
checkLastTagWas(0);
return this;
} catch (final
InvalidProtocolBufferException e) {
throw
e;
} catch (final
IOException e) {
throw new
RuntimeException(
"Reading from a ByteString threw an IOException (should " +
"never happen).",
e);
}
}
/**
* Parse {@code data} as an {@code UnknownFieldSet} and merge it with the
* set being built. This is just a small wrapper around
* {@link #mergeFrom(CodedInputStream)}.
*/
@
Override
public
Builder mergeFrom(final byte[]
data) throws
InvalidProtocolBufferException {
try {
final
CodedInputStream input =
CodedInputStream.
newInstance(
data);
mergeFrom(
input);
input.
checkLastTagWas(0);
return this;
} catch (final
InvalidProtocolBufferException e) {
throw
e;
} catch (final
IOException e) {
throw new
RuntimeException(
"Reading from a byte array threw an IOException (should " +
"never happen).",
e);
}
}
/**
* Parse an {@code UnknownFieldSet} from {@code input} and merge it with the
* set being built. This is just a small wrapper around
* {@link #mergeFrom(CodedInputStream)}.
*/
@
Override
public
Builder mergeFrom(final
InputStream input) throws
IOException {
final
CodedInputStream codedInput =
CodedInputStream.
newInstance(
input);
mergeFrom(
codedInput);
codedInput.
checkLastTagWas(0);
return this;
}
@
Override
public boolean
mergeDelimitedFrom(
InputStream input) throws
IOException {
final int
firstByte =
input.
read();
if (
firstByte == -1) {
return false;
}
final int
size =
CodedInputStream.
readRawVarint32(
firstByte,
input);
final
InputStream limitedInput = new
LimitedInputStream(
input,
size);
mergeFrom(
limitedInput);
return true;
}
@
Override
public boolean
mergeDelimitedFrom(
InputStream input,
ExtensionRegistryLite extensionRegistry)
throws
IOException {
// UnknownFieldSet has no extensions.
return
mergeDelimitedFrom(
input);
}
@
Override
public
Builder mergeFrom(
CodedInputStream input,
ExtensionRegistryLite extensionRegistry)
throws
IOException {
// UnknownFieldSet has no extensions.
return
mergeFrom(
input);
}
@
Override
public
Builder mergeFrom(
ByteString data,
ExtensionRegistryLite extensionRegistry)
throws
InvalidProtocolBufferException {
// UnknownFieldSet has no extensions.
return
mergeFrom(
data);
}
@
Override
public
Builder mergeFrom(byte[]
data, int
off, int
len) throws
InvalidProtocolBufferException {
try {
final
CodedInputStream input =
CodedInputStream.
newInstance(
data,
off,
len);
mergeFrom(
input);
input.
checkLastTagWas(0);
return this;
} catch (
InvalidProtocolBufferException e) {
throw
e;
} catch (
IOException e) {
throw new
RuntimeException(
"Reading from a byte array threw an IOException (should " +
"never happen).",
e);
}
}
@
Override
public
Builder mergeFrom(byte[]
data,
ExtensionRegistryLite extensionRegistry)
throws
InvalidProtocolBufferException {
// UnknownFieldSet has no extensions.
return
mergeFrom(
data);
}
@
Override
public
Builder mergeFrom(byte[]
data, int
off, int
len,
ExtensionRegistryLite extensionRegistry)
throws
InvalidProtocolBufferException {
// UnknownFieldSet has no extensions.
return
mergeFrom(
data,
off,
len);
}
@
Override
public
Builder mergeFrom(
InputStream input,
ExtensionRegistryLite extensionRegistry)
throws
IOException {
// UnknownFieldSet has no extensions.
return
mergeFrom(
input);
}
@
Override
public
Builder mergeFrom(
MessageLite m) {
if (
m instanceof
UnknownFieldSet) {
return
mergeFrom((
UnknownFieldSet)
m);
}
throw new
IllegalArgumentException(
"mergeFrom(MessageLite) can only merge messages of the same type.");
}
@
Override
public boolean
isInitialized() {
// UnknownFieldSets do not have required fields, so they are always
// initialized.
return true;
}
}
/**
* Represents a single field in an {@code UnknownFieldSet}.
*
* <p>A {@code Field} consists of five lists of values. The lists correspond
* to the five "wire types" used in the protocol buffer binary format.
* The wire type of each field can be determined from the encoded form alone,
* without knowing the field's declared type. So, we are able to parse
* unknown values at least this far and separate them. Normally, only one
* of the five lists will contain any values, since it is impossible to
* define a valid message type that declares two different types for the
* same field number. However, the code is designed to allow for the case
* where the same unknown field number is encountered using multiple different
* wire types.
*
* <p>{@code Field} is an immutable class. To construct one, you must use a
* {@link Builder}.
*
* @see UnknownFieldSet
*/
public static final class
Field {
private
Field() {}
/** Construct a new {@link Builder}. */
public static
Builder newBuilder() {
return
Builder.
create();
}
/**
* Construct a new {@link Builder} and initialize it to a copy of
* {@code copyFrom}.
*/
public static
Builder newBuilder(final
Field copyFrom) {
return
newBuilder().
mergeFrom(
copyFrom);
}
/** Get an empty {@code Field}. */
public static
Field getDefaultInstance() {
return
fieldDefaultInstance;
}
private static final
Field fieldDefaultInstance =
newBuilder().
build();
/** Get the list of varint values for this field. */
public
List<
Long>
getVarintList() { return
varint; }
/** Get the list of fixed32 values for this field. */
public
List<
Integer>
getFixed32List() { return
fixed32; }
/** Get the list of fixed64 values for this field. */
public
List<
Long>
getFixed64List() { return
fixed64; }
/** Get the list of length-delimited values for this field. */
public
List<
ByteString>
getLengthDelimitedList() { return
lengthDelimited; }
/**
* Get the list of embedded group values for this field. These are
* represented using {@link UnknownFieldSet}s rather than {@link Message}s
* since the group's type is presumably unknown.
*/
public
List<
UnknownFieldSet>
getGroupList() { return
group; }
@
Override
public boolean
equals(final
Object other) {
if (this ==
other) {
return true;
}
if (!(
other instanceof
Field)) {
return false;
}
return
Arrays.
equals(
getIdentityArray(),
((
Field)
other).
getIdentityArray());
}
@
Override
public int
hashCode() {
return
Arrays.
hashCode(
getIdentityArray());
}
/**
* Returns the array of objects to be used to uniquely identify this
* {@link Field} instance.
*/
private
Object[]
getIdentityArray() {
return new
Object[] {
varint,
fixed32,
fixed64,
lengthDelimited,
group};
}
/**
* Serializes the field, including field number, and writes it to
* {@code output}.
*/
public void
writeTo(final int
fieldNumber, final
CodedOutputStream output)
throws
IOException {
for (final long
value :
varint) {
output.
writeUInt64(
fieldNumber,
value);
}
for (final int
value :
fixed32) {
output.
writeFixed32(
fieldNumber,
value);
}
for (final long
value :
fixed64) {
output.
writeFixed64(
fieldNumber,
value);
}
for (final
ByteString value :
lengthDelimited) {
output.
writeBytes(
fieldNumber,
value);
}
for (final
UnknownFieldSet value :
group) {
output.
writeGroup(
fieldNumber,
value);
}
}
/**
* Get the number of bytes required to encode this field, including field
* number.
*/
public int
getSerializedSize(final int
fieldNumber) {
int
result = 0;
for (final long
value :
varint) {
result +=
CodedOutputStream.
computeUInt64Size(
fieldNumber,
value);
}
for (final int
value :
fixed32) {
result +=
CodedOutputStream.
computeFixed32Size(
fieldNumber,
value);
}
for (final long
value :
fixed64) {
result +=
CodedOutputStream.
computeFixed64Size(
fieldNumber,
value);
}
for (final
ByteString value :
lengthDelimited) {
result +=
CodedOutputStream.
computeBytesSize(
fieldNumber,
value);
}
for (final
UnknownFieldSet value :
group) {
result +=
CodedOutputStream.
computeGroupSize(
fieldNumber,
value);
}
return
result;
}
/**
* Serializes the field, including field number, and writes it to
* {@code output}, using {@code MessageSet} wire format.
*/
public void
writeAsMessageSetExtensionTo(
final int
fieldNumber,
final
CodedOutputStream output)
throws
IOException {
for (final
ByteString value :
lengthDelimited) {
output.
writeRawMessageSetExtension(
fieldNumber,
value);
}
}
/**
* Get the number of bytes required to encode this field, including field number, using {@code
* MessageSet} wire format.
*/
public int
getSerializedSizeAsMessageSetExtension(final int
fieldNumber) {
int
result = 0;
for (final
ByteString value :
lengthDelimited) {
result +=
CodedOutputStream.
computeRawMessageSetExtensionSize(
fieldNumber,
value);
}
return
result;
}
private
List<
Long>
varint;
private
List<
Integer>
fixed32;
private
List<
Long>
fixed64;
private
List<
ByteString>
lengthDelimited;
private
List<
UnknownFieldSet>
group;
/**
* Used to build a {@link Field} within an {@link UnknownFieldSet}.
*
* <p>Use {@link Field#newBuilder()} to construct a {@code Builder}.
*/
public static final class
Builder {
// This constructor should never be called directly (except from 'create').
private
Builder() {}
private static
Builder create() {
Builder builder = new
Builder();
builder.
result = new
Field();
return
builder;
}
private
Field result;
/**
* Build the field. After {@code build()} has been called, the
* {@code Builder} is no longer usable. Calling any other method will
* result in undefined behavior and can cause a
* {@code NullPointerException} to be thrown.
*/
public
Field build() {
if (
result.
varint == null) {
result.
varint =
Collections.
emptyList();
} else {
result.
varint =
Collections.
unmodifiableList(
result.
varint);
}
if (
result.
fixed32 == null) {
result.
fixed32 =
Collections.
emptyList();
} else {
result.
fixed32 =
Collections.
unmodifiableList(
result.
fixed32);
}
if (
result.
fixed64 == null) {
result.
fixed64 =
Collections.
emptyList();
} else {
result.
fixed64 =
Collections.
unmodifiableList(
result.
fixed64);
}
if (
result.
lengthDelimited == null) {
result.
lengthDelimited =
Collections.
emptyList();
} else {
result.
lengthDelimited =
Collections.
unmodifiableList(
result.
lengthDelimited);
}
if (
result.
group == null) {
result.
group =
Collections.
emptyList();
} else {
result.
group =
Collections.
unmodifiableList(
result.
group);
}
final
Field returnMe =
result;
result = null;
return
returnMe;
}
/** Discard the field's contents. */
public
Builder clear() {
result = new
Field();
return this;
}
/**
* Merge the values in {@code other} into this field. For each list
* of values, {@code other}'s values are append to the ones in this
* field.
*/
public
Builder mergeFrom(final
Field other) {
if (!
other.
varint.
isEmpty()) {
if (
result.
varint == null) {
result.
varint = new
ArrayList<
Long>();
}
result.
varint.
addAll(
other.
varint);
}
if (!
other.
fixed32.
isEmpty()) {
if (
result.
fixed32 == null) {
result.
fixed32 = new
ArrayList<
Integer>();
}
result.
fixed32.
addAll(
other.
fixed32);
}
if (!
other.
fixed64.
isEmpty()) {
if (
result.
fixed64 == null) {
result.
fixed64 = new
ArrayList<
Long>();
}
result.
fixed64.
addAll(
other.
fixed64);
}
if (!
other.
lengthDelimited.
isEmpty()) {
if (
result.
lengthDelimited == null) {
result.
lengthDelimited = new
ArrayList<
ByteString>();
}
result.
lengthDelimited.
addAll(
other.
lengthDelimited);
}
if (!
other.
group.
isEmpty()) {
if (
result.
group == null) {
result.
group = new
ArrayList<
UnknownFieldSet>();
}
result.
group.
addAll(
other.
group);
}
return this;
}
/** Add a varint value. */
public
Builder addVarint(final long
value) {
if (
result.
varint == null) {
result.
varint = new
ArrayList<
Long>();
}
result.
varint.
add(
value);
return this;
}
/** Add a fixed32 value. */
public
Builder addFixed32(final int
value) {
if (
result.
fixed32 == null) {
result.
fixed32 = new
ArrayList<
Integer>();
}
result.
fixed32.
add(
value);
return this;
}
/** Add a fixed64 value. */
public
Builder addFixed64(final long
value) {
if (
result.
fixed64 == null) {
result.
fixed64 = new
ArrayList<
Long>();
}
result.
fixed64.
add(
value);
return this;
}
/** Add a length-delimited value. */
public
Builder addLengthDelimited(final
ByteString value) {
if (
result.
lengthDelimited == null) {
result.
lengthDelimited = new
ArrayList<
ByteString>();
}
result.
lengthDelimited.
add(
value);
return this;
}
/** Add an embedded group. */
public
Builder addGroup(final
UnknownFieldSet value) {
if (
result.
group == null) {
result.
group = new
ArrayList<
UnknownFieldSet>();
}
result.
group.
add(
value);
return this;
}
}
}
/**
* Parser to implement MessageLite interface.
*/
public static final class
Parser extends
AbstractParser<
UnknownFieldSet> {
@
Override
public
UnknownFieldSet parsePartialFrom(
CodedInputStream input,
ExtensionRegistryLite extensionRegistry)
throws
InvalidProtocolBufferException {
Builder builder =
newBuilder();
try {
builder.
mergeFrom(
input);
} catch (
InvalidProtocolBufferException e) {
throw
e.
setUnfinishedMessage(
builder.
buildPartial());
} catch (
IOException e) {
throw new
InvalidProtocolBufferException(
e)
.
setUnfinishedMessage(
builder.
buildPartial());
}
return
builder.
buildPartial();
}
}
private static final
Parser PARSER = new
Parser();
@
Override
public final
Parser getParserForType() {
return
PARSER;
}
}