Subversion Repositories Code-Repo

// Protocol Buffers - Google's data interchange format

// Copyright 2008 Google Inc.  All rights reserved.

// http://code.google.com/p/protobuf/

//

// 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.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 feilds 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() {}

  /** 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;

  }

  public UnknownFieldSet getDefaultInstanceForType() {

    return defaultInstance;

  }

  private static final UnknownFieldSet defaultInstance =

    new UnknownFieldSet(Collections.<Integer, Field>emptyMap());

  /**

   * Construct an {@code UnknownFieldSet} around the given map.  The map is

   * expected to be immutable.

   */

  private UnknownFieldSet(final Map<Integer, Field> fields) {

    this.fields = fields;

  }

  private 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}. */

  public void writeTo(final CodedOutputStream output) throws IOException {

    for (final Map.Entry<Integer, Field> entry : fields.entrySet()) {

      entry.getValue().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)}.

   */

  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)}.

   */

  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)}.

   */

  public void writeTo(final OutputStream output) throws IOException {

    final CodedOutputStream codedOutput = CodedOutputStream.newInstance(output);

    writeTo(codedOutput);

    codedOutput.flush();

  }

  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. */

  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;

  }

  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();

  }

  public Builder newBuilderForType() {

    return newBuilder();

  }

  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.

     */

    public UnknownFieldSet build() {

      getFieldBuilder(0);  // Force lastField to be built.

      final UnknownFieldSet result;

      if (fields.isEmpty()) {

        result = getDefaultInstance();

      } else {

        result = new UnknownFieldSet(Collections.unmodifiableMap(fields));

      }

      fields = null;

      return result;

    }

    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.

      return UnknownFieldSet.newBuilder().mergeFrom(

          new UnknownFieldSet(fields));

    }

    public UnknownFieldSet getDefaultInstanceForType() {

      return UnknownFieldSet.getDefaultInstance();

    }

    private void reinitialize() {

      fields = Collections.emptyMap();

      lastFieldNumber = 0;

      lastField = null;

    }

    /** Reset the builder to an empty set. */

    public Builder clear() {

      reinitialize();

      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;

    }

    /** 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.

     */

    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 engroup 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)}.

     */

    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)}.

     */

    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)}.

     */

    public Builder mergeFrom(final InputStream input) throws IOException {

      final CodedInputStream codedInput = CodedInputStream.newInstance(input);

      mergeFrom(codedInput);

      codedInput.checkLastTagWas(0);

      return this;

    }

    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;

    }

    public boolean mergeDelimitedFrom(

        InputStream input,

        ExtensionRegistryLite extensionRegistry) throws IOException {

      // UnknownFieldSet has no extensions.

      return mergeDelimitedFrom(input);

    }

    public Builder mergeFrom(

        CodedInputStream input,

        ExtensionRegistryLite extensionRegistry) throws IOException {

      // UnknownFieldSet has no extensions.

      return mergeFrom(input);

    }

    public Builder mergeFrom(

        ByteString data,

        ExtensionRegistryLite extensionRegistry)

        throws InvalidProtocolBufferException {

      // UnknownFieldSet has no extensions.

      return mergeFrom(data);

    }

    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);

      }

    }

    public Builder mergeFrom(

        byte[] data,

        ExtensionRegistryLite extensionRegistry)

        throws InvalidProtocolBufferException {

      // UnknownFieldSet has no extensions.

      return mergeFrom(data);

    }

    public Builder mergeFrom(

        byte[] data, int off, int len,

        ExtensionRegistryLite extensionRegistry)

        throws InvalidProtocolBufferException {

      // UnknownFieldSet has no extensions.

      return mergeFrom(data, off, len);

    }

    public Builder mergeFrom(

        InputStream input,

        ExtensionRegistryLite extensionRegistry) throws IOException {

      // UnknownFieldSet has no extensions.

      return mergeFrom(input);

    }

    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;

      }

    }

  }

}