java/core/src/main/java/com/google/protobuf/AbstractMessageLite.java - third_party/protobuf - Git at Google

 // 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 static com.google.protobuf.Internal.checkNotNull;

 import java.io.FilterInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;

 /**
  * A partial implementation of the {@link MessageLite} interface which implements as many methods of
  * that interface as possible in terms of other methods.
  *
  * @author kenton@google.com Kenton Varda
  */
 public abstract class AbstractMessageLite<
         MessageType extends AbstractMessageLite<MessageType, BuilderType>,
         BuilderType extends AbstractMessageLite.Builder<MessageType, BuilderType>>
     implements MessageLite {
   protected int memoizedHashCode = 0;
   @Override
   public ByteString toByteString() {
     try {
       final ByteString.CodedBuilder out = ByteString.newCodedBuilder(getSerializedSize());
       writeTo(out.getCodedOutput());
       return out.build();
     } catch (IOException e) {
       throw new RuntimeException(getSerializingExceptionMessage("ByteString"), e);
     }
   }

   @Override
   public byte[] toByteArray() {
     try {
       final byte[] result = new byte[getSerializedSize()];
       final CodedOutputStream output = CodedOutputStream.newInstance(result);
       writeTo(output);
       output.checkNoSpaceLeft();
       return result;
     } catch (IOException e) {
       throw new RuntimeException(getSerializingExceptionMessage("byte array"), e);
     }
   }

   @Override
   public void writeTo(final OutputStream output) throws IOException {
     final int bufferSize = CodedOutputStream.computePreferredBufferSize(getSerializedSize());
     final CodedOutputStream codedOutput = CodedOutputStream.newInstance(output, bufferSize);
     writeTo(codedOutput);
     codedOutput.flush();
   }

   @Override
   public void writeDelimitedTo(final OutputStream output) throws IOException {
     final int serialized = getSerializedSize();
     final int bufferSize =
         CodedOutputStream.computePreferredBufferSize(
             CodedOutputStream.computeRawVarint32Size(serialized) + serialized);
     final CodedOutputStream codedOutput = CodedOutputStream.newInstance(output, bufferSize);
     codedOutput.writeRawVarint32(serialized);
     writeTo(codedOutput);
     codedOutput.flush();
   }

   // We'd like these to be abstract but some folks are extending this class directly. They shouldn't
   // be doing that and they should feel bad.
   int getMemoizedSerializedSize() {
     throw new UnsupportedOperationException();
   }

   void setMemoizedSerializedSize(int size) {
     throw new UnsupportedOperationException();
   }


   @ExperimentalApi
   protected final boolean isInitializedInternal() {
     return Protobuf.getInstance().schemaFor(this).isInitialized(this);
   }

   @ExperimentalApi
   protected final int getSerializedSizeInternal() {
     return Protobuf.getInstance().schemaFor(this).getSerializedSize(this);
   }

   int getSerializedSize(Schema schema) {
     int memoizedSerializedSize = getMemoizedSerializedSize();
     if (memoizedSerializedSize == -1) {
       memoizedSerializedSize = schema.getSerializedSize(this);
       setMemoizedSerializedSize(memoizedSerializedSize);
     }
     return memoizedSerializedSize;
   }

   @ExperimentalApi
   protected final void writeToInternal(CodedOutputStream output) throws IOException {
     Protobuf.getInstance()
         .schemaFor(getClassInternal())
         .writeTo(this, CodedOutputStreamWriter.forCodedOutput(output));
   }

   @ExperimentalApi
   protected void mergeFromInternal(CodedInputStream input, ExtensionRegistryLite extensionRegistry)
       throws InvalidProtocolBufferException {
     try {
       Protobuf.getInstance()
           .schemaFor(getClassInternal())
           .mergeFrom(this, CodedInputStreamReader.forCodedInput(input), extensionRegistry);
     } catch (InvalidProtocolBufferException e) {
       throw e.setUnfinishedMessage(this);
     } catch (IOException e) {
       throw new InvalidProtocolBufferException(e).setUnfinishedMessage(this);
     }
   }

   @ExperimentalApi
   protected void makeImmutableInternal() {
     Protobuf.getInstance().schemaFor(getClassInternal()).makeImmutable(this);
   }

   @SuppressWarnings("unchecked")
   private Class<AbstractMessageLite<MessageType, BuilderType>> getClassInternal() {
     return (Class<AbstractMessageLite<MessageType, BuilderType>>) getClass();
   }

   /** Package private helper method for AbstractParser to create UninitializedMessageException. */
   UninitializedMessageException newUninitializedMessageException() {
     return new UninitializedMessageException(this);
   }

   private String getSerializingExceptionMessage(String target) {
     return "Serializing "
         + getClass().getName()
         + " to a "
         + target
         + " threw an IOException (should never happen).";
   }

   protected static void checkByteStringIsUtf8(ByteString byteString)
       throws IllegalArgumentException {
     if (!byteString.isValidUtf8()) {
       throw new IllegalArgumentException("Byte string is not UTF-8.");
     }
   }

   // For binary compatibility
   @Deprecated
   protected static <T> void addAll(final Iterable<T> values, final Collection<? super T> list) {
     Builder.addAll(values, (List) list);
   }

   protected static <T> void addAll(final Iterable<T> values, final List<? super T> list) {
     Builder.addAll(values, list);
   }

   /**
    * A partial implementation of the {@link Message.Builder} interface which implements as many
    * methods of that interface as possible in terms of other methods.
    */
   @SuppressWarnings("unchecked")
   public abstract static class Builder<
           MessageType extends AbstractMessageLite<MessageType, BuilderType>,
           BuilderType extends Builder<MessageType, BuilderType>>
       implements MessageLite.Builder {
     // The compiler produces an error if this is not declared explicitly.
     @Override
     public abstract BuilderType clone();

     @Override
     public BuilderType mergeFrom(final CodedInputStream input) throws IOException {
       return mergeFrom(input, ExtensionRegistryLite.getEmptyRegistry());
     }

     // Re-defined here for return type covariance.
     @Override
     public abstract BuilderType mergeFrom(
         final CodedInputStream input, final ExtensionRegistryLite extensionRegistry)
         throws IOException;

     @Override
     public BuilderType mergeFrom(final ByteString data) throws InvalidProtocolBufferException {
       try {
         final CodedInputStream input = data.newCodedInput();
         mergeFrom(input);
         input.checkLastTagWas(0);
         return (BuilderType) this;
       } catch (InvalidProtocolBufferException e) {
         throw e;
       } catch (IOException e) {
         throw new RuntimeException(getReadingExceptionMessage("ByteString"), e);
       }
     }

     @Override
     public BuilderType mergeFrom(
         final ByteString data, final ExtensionRegistryLite extensionRegistry)
         throws InvalidProtocolBufferException {
       try {
         final CodedInputStream input = data.newCodedInput();
         mergeFrom(input, extensionRegistry);
         input.checkLastTagWas(0);
         return (BuilderType) this;
       } catch (InvalidProtocolBufferException e) {
         throw e;
       } catch (IOException e) {
         throw new RuntimeException(getReadingExceptionMessage("ByteString"), e);
       }
     }

     @Override
     public BuilderType mergeFrom(final byte[] data) throws InvalidProtocolBufferException {
       return mergeFrom(data, 0, data.length);
     }

     @Override
     public BuilderType mergeFrom(final byte[] data, final int off, final int len)
         throws InvalidProtocolBufferException {
       try {
         final CodedInputStream input = CodedInputStream.newInstance(data, off, len);
         mergeFrom(input);
         input.checkLastTagWas(0);
         return (BuilderType) this;
       } catch (InvalidProtocolBufferException e) {
         throw e;
       } catch (IOException e) {
         throw new RuntimeException(getReadingExceptionMessage("byte array"), e);
       }
     }

     @Override
     public BuilderType mergeFrom(final byte[] data, final ExtensionRegistryLite extensionRegistry)
         throws InvalidProtocolBufferException {
       return mergeFrom(data, 0, data.length, extensionRegistry);
     }

     @Override
     public BuilderType mergeFrom(
         final byte[] data,
         final int off,
         final int len,
         final ExtensionRegistryLite extensionRegistry)
         throws InvalidProtocolBufferException {
       try {
         final CodedInputStream input = CodedInputStream.newInstance(data, off, len);
         mergeFrom(input, extensionRegistry);
         input.checkLastTagWas(0);
         return (BuilderType) this;
       } catch (InvalidProtocolBufferException e) {
         throw e;
       } catch (IOException e) {
         throw new RuntimeException(getReadingExceptionMessage("byte array"), e);
       }
     }

     @Override
     public BuilderType mergeFrom(final InputStream input) throws IOException {
       final CodedInputStream codedInput = CodedInputStream.newInstance(input);
       mergeFrom(codedInput);
       codedInput.checkLastTagWas(0);
       return (BuilderType) this;
     }

     @Override
     public BuilderType mergeFrom(
         final InputStream input, final ExtensionRegistryLite extensionRegistry) throws IOException {
       final CodedInputStream codedInput = CodedInputStream.newInstance(input);
       mergeFrom(codedInput, extensionRegistry);
       codedInput.checkLastTagWas(0);
       return (BuilderType) this;
     }

     /**
      * An InputStream implementations which reads from some other InputStream but is limited to a
      * particular number of bytes. Used by mergeDelimitedFrom(). This is intentionally
      * package-private so that UnknownFieldSet can share it.
      */
     static final class LimitedInputStream extends FilterInputStream {
       private int limit;

       LimitedInputStream(InputStream in, int limit) {
         super(in);
         this.limit = limit;
       }

       @Override
       public int available() throws IOException {
         return Math.min(super.available(), limit);
       }

       @Override
       public int read() throws IOException {
         if (limit <= 0) {
           return -1;
         }
         final int result = super.read();
         if (result >= 0) {
           --limit;
         }
         return result;
       }

       @Override
       public int read(final byte[] b, final int off, int len) throws IOException {
         if (limit <= 0) {
           return -1;
         }
         len = Math.min(len, limit);
         final int result = super.read(b, off, len);
         if (result >= 0) {
           limit -= result;
         }
         return result;
       }

       @Override
       public long skip(final long n) throws IOException {
         final long result = super.skip(Math.min(n, limit));
         if (result >= 0) {
           limit -= result;
         }
         return result;
       }
     }

     @Override
     public boolean mergeDelimitedFrom(
         final InputStream input, final ExtensionRegistryLite extensionRegistry) 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, extensionRegistry);
       return true;
     }

     @Override
     public boolean mergeDelimitedFrom(final InputStream input) throws IOException {
       return mergeDelimitedFrom(input, ExtensionRegistryLite.getEmptyRegistry());
     }

     @Override
     @SuppressWarnings("unchecked") // isInstance takes care of this
     public BuilderType mergeFrom(final MessageLite other) {
       if (!getDefaultInstanceForType().getClass().isInstance(other)) {
         throw new IllegalArgumentException(
             "mergeFrom(MessageLite) can only merge messages of the same type.");
       }

       return internalMergeFrom((MessageType) other);
     }

     protected abstract BuilderType internalMergeFrom(MessageType message);

     private String getReadingExceptionMessage(String target) {
       return "Reading "
           + getClass().getName()
           + " from a "
           + target
           + " threw an IOException (should never happen).";
     }

     // We check nulls as we iterate to avoid iterating over values twice.
     private static <T> void addAllCheckingNulls(Iterable<T> values, List<? super T> list) {
       if (list instanceof ArrayList && values instanceof Collection) {
         ((ArrayList<T>) list).ensureCapacity(list.size() + ((Collection<T>) values).size());
       }
       int begin = list.size();
       for (T value : values) {
         if (value == null) {
           // encountered a null value so we must undo our modifications prior to throwing
           String message = "Element at index " + (list.size() - begin) + " is null.";
           for (int i = list.size() - 1; i >= begin; i--) {
             list.remove(i);
           }
           throw new NullPointerException(message);
         }
         list.add(value);
       }
     }

     /** Construct an UninitializedMessageException reporting missing fields in the given message. */
     protected static UninitializedMessageException newUninitializedMessageException(
         MessageLite message) {
       return new UninitializedMessageException(message);
     }

     // For binary compatibility.
     @Deprecated
     protected static <T> void addAll(final Iterable<T> values, final Collection<? super T> list) {
       addAll(values, (List<T>) list);
     }

     /**
      * Adds the {@code values} to the {@code list}. This is a helper method used by generated code.
      * Users should ignore it.
      *
      * @throws NullPointerException if {@code values} or any of the elements of {@code values} is
      *     null.
      */
     protected static <T> void addAll(final Iterable<T> values, final List<? super T> list) {
       checkNotNull(values);
       if (values instanceof LazyStringList) {
         // For StringOrByteStringLists, check the underlying elements to avoid
         // forcing conversions of ByteStrings to Strings.
         // TODO(dweis): Could we just prohibit nulls in all protobuf lists and get rid of this? Is
         // if even possible to hit this condition as all protobuf methods check for null first,
         // right?
         List<?> lazyValues = ((LazyStringList) values).getUnderlyingElements();
         LazyStringList lazyList = (LazyStringList) list;
         int begin = list.size();
         for (Object value : lazyValues) {
           if (value == null) {
             // encountered a null value so we must undo our modifications prior to throwing
             String message = "Element at index " + (lazyList.size() - begin) + " is null.";
             for (int i = lazyList.size() - 1; i >= begin; i--) {
               lazyList.remove(i);
             }
             throw new NullPointerException(message);
           }
           if (value instanceof ByteString) {
             lazyList.add((ByteString) value);
           } else {
             lazyList.add((String) value);
           }
         }
       } else {
         if (values instanceof PrimitiveNonBoxingCollection) {
           list.addAll((Collection<T>) values);
         } else {
           addAllCheckingNulls(values, list);
         }
       }
     }
   }
 }
	// 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 static com.google.protobuf.Internal.checkNotNull;

	import java.io.FilterInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.List;

	/**
	* A partial implementation of the {@link MessageLite} interface which implements as many methods of
	* that interface as possible in terms of other methods.
	*
	* @author kenton@google.com Kenton Varda
	*/
	public abstract class AbstractMessageLite<
	MessageType extends AbstractMessageLite<MessageType, BuilderType>,
	BuilderType extends AbstractMessageLite.Builder<MessageType, BuilderType>>
	implements MessageLite {
	protected int memoizedHashCode = 0;
	@Override
	public ByteString toByteString() {
	try {
	final ByteString.CodedBuilder out = ByteString.newCodedBuilder(getSerializedSize());
	writeTo(out.getCodedOutput());
	return out.build();
	} catch (IOException e) {
	throw new RuntimeException(getSerializingExceptionMessage("ByteString"), e);
	}
	}

	@Override
	public byte[] toByteArray() {
	try {
	final byte[] result = new byte[getSerializedSize()];
	final CodedOutputStream output = CodedOutputStream.newInstance(result);
	writeTo(output);
	output.checkNoSpaceLeft();
	return result;
	} catch (IOException e) {
	throw new RuntimeException(getSerializingExceptionMessage("byte array"), e);
	}
	}

	@Override
	public void writeTo(final OutputStream output) throws IOException {
	final int bufferSize = CodedOutputStream.computePreferredBufferSize(getSerializedSize());
	final CodedOutputStream codedOutput = CodedOutputStream.newInstance(output, bufferSize);
	writeTo(codedOutput);
	codedOutput.flush();
	}

	@Override
	public void writeDelimitedTo(final OutputStream output) throws IOException {
	final int serialized = getSerializedSize();
	final int bufferSize =
	CodedOutputStream.computePreferredBufferSize(
	CodedOutputStream.computeRawVarint32Size(serialized) + serialized);
	final CodedOutputStream codedOutput = CodedOutputStream.newInstance(output, bufferSize);
	codedOutput.writeRawVarint32(serialized);
	writeTo(codedOutput);
	codedOutput.flush();
	}

	// We'd like these to be abstract but some folks are extending this class directly. They shouldn't
	// be doing that and they should feel bad.
	int getMemoizedSerializedSize() {
	throw new UnsupportedOperationException();
	}

	void setMemoizedSerializedSize(int size) {
	throw new UnsupportedOperationException();
	}


	@ExperimentalApi
	protected final boolean isInitializedInternal() {
	return Protobuf.getInstance().schemaFor(this).isInitialized(this);
	}

	@ExperimentalApi
	protected final int getSerializedSizeInternal() {
	return Protobuf.getInstance().schemaFor(this).getSerializedSize(this);
	}

	int getSerializedSize(Schema schema) {
	int memoizedSerializedSize = getMemoizedSerializedSize();
	if (memoizedSerializedSize == -1) {
	memoizedSerializedSize = schema.getSerializedSize(this);
	setMemoizedSerializedSize(memoizedSerializedSize);
	}
	return memoizedSerializedSize;
	}

	@ExperimentalApi
	protected final void writeToInternal(CodedOutputStream output) throws IOException {
	Protobuf.getInstance()
	.schemaFor(getClassInternal())
	.writeTo(this, CodedOutputStreamWriter.forCodedOutput(output));
	}

	@ExperimentalApi
	protected void mergeFromInternal(CodedInputStream input, ExtensionRegistryLite extensionRegistry)
	throws InvalidProtocolBufferException {
	try {
	Protobuf.getInstance()
	.schemaFor(getClassInternal())
	.mergeFrom(this, CodedInputStreamReader.forCodedInput(input), extensionRegistry);
	} catch (InvalidProtocolBufferException e) {
	throw e.setUnfinishedMessage(this);
	} catch (IOException e) {
	throw new InvalidProtocolBufferException(e).setUnfinishedMessage(this);
	}
	}

	@ExperimentalApi
	protected void makeImmutableInternal() {
	Protobuf.getInstance().schemaFor(getClassInternal()).makeImmutable(this);
	}

	@SuppressWarnings("unchecked")
	private Class<AbstractMessageLite<MessageType, BuilderType>> getClassInternal() {
	return (Class<AbstractMessageLite<MessageType, BuilderType>>) getClass();
	}

	/** Package private helper method for AbstractParser to create UninitializedMessageException. */
	UninitializedMessageException newUninitializedMessageException() {
	return new UninitializedMessageException(this);
	}

	private String getSerializingExceptionMessage(String target) {
	return "Serializing "
	+ getClass().getName()
	+ " to a "
	+ target
	+ " threw an IOException (should never happen).";
	}

	protected static void checkByteStringIsUtf8(ByteString byteString)
	throws IllegalArgumentException {
	if (!byteString.isValidUtf8()) {
	throw new IllegalArgumentException("Byte string is not UTF-8.");
	}
	}

	// For binary compatibility
	@Deprecated
	protected static <T> void addAll(final Iterable<T> values, final Collection<? super T> list) {
	Builder.addAll(values, (List) list);
	}

	protected static <T> void addAll(final Iterable<T> values, final List<? super T> list) {
	Builder.addAll(values, list);
	}

	/**
	* A partial implementation of the {@link Message.Builder} interface which implements as many
	* methods of that interface as possible in terms of other methods.
	*/
	@SuppressWarnings("unchecked")
	public abstract static class Builder<
	MessageType extends AbstractMessageLite<MessageType, BuilderType>,
	BuilderType extends Builder<MessageType, BuilderType>>
	implements MessageLite.Builder {
	// The compiler produces an error if this is not declared explicitly.
	@Override
	public abstract BuilderType clone();

	@Override
	public BuilderType mergeFrom(final CodedInputStream input) throws IOException {
	return mergeFrom(input, ExtensionRegistryLite.getEmptyRegistry());
	}

	// Re-defined here for return type covariance.
	@Override
	public abstract BuilderType mergeFrom(
	final CodedInputStream input, final ExtensionRegistryLite extensionRegistry)
	throws IOException;

	@Override
	public BuilderType mergeFrom(final ByteString data) throws InvalidProtocolBufferException {
	try {
	final CodedInputStream input = data.newCodedInput();
	mergeFrom(input);
	input.checkLastTagWas(0);
	return (BuilderType) this;
	} catch (InvalidProtocolBufferException e) {
	throw e;
	} catch (IOException e) {
	throw new RuntimeException(getReadingExceptionMessage("ByteString"), e);
	}
	}

	@Override
	public BuilderType mergeFrom(
	final ByteString data, final ExtensionRegistryLite extensionRegistry)
	throws InvalidProtocolBufferException {
	try {
	final CodedInputStream input = data.newCodedInput();
	mergeFrom(input, extensionRegistry);
	input.checkLastTagWas(0);
	return (BuilderType) this;
	} catch (InvalidProtocolBufferException e) {
	throw e;
	} catch (IOException e) {
	throw new RuntimeException(getReadingExceptionMessage("ByteString"), e);
	}
	}

	@Override
	public BuilderType mergeFrom(final byte[] data) throws InvalidProtocolBufferException {
	return mergeFrom(data, 0, data.length);
	}

	@Override
	public BuilderType mergeFrom(final byte[] data, final int off, final int len)
	throws InvalidProtocolBufferException {
	try {
	final CodedInputStream input = CodedInputStream.newInstance(data, off, len);
	mergeFrom(input);
	input.checkLastTagWas(0);
	return (BuilderType) this;
	} catch (InvalidProtocolBufferException e) {
	throw e;
	} catch (IOException e) {
	throw new RuntimeException(getReadingExceptionMessage("byte array"), e);
	}
	}

	@Override
	public BuilderType mergeFrom(final byte[] data, final ExtensionRegistryLite extensionRegistry)
	throws InvalidProtocolBufferException {
	return mergeFrom(data, 0, data.length, extensionRegistry);
	}

	@Override
	public BuilderType mergeFrom(
	final byte[] data,
	final int off,
	final int len,
	final ExtensionRegistryLite extensionRegistry)
	throws InvalidProtocolBufferException {
	try {
	final CodedInputStream input = CodedInputStream.newInstance(data, off, len);
	mergeFrom(input, extensionRegistry);
	input.checkLastTagWas(0);
	return (BuilderType) this;
	} catch (InvalidProtocolBufferException e) {
	throw e;
	} catch (IOException e) {
	throw new RuntimeException(getReadingExceptionMessage("byte array"), e);
	}
	}

	@Override
	public BuilderType mergeFrom(final InputStream input) throws IOException {
	final CodedInputStream codedInput = CodedInputStream.newInstance(input);
	mergeFrom(codedInput);
	codedInput.checkLastTagWas(0);
	return (BuilderType) this;
	}

	@Override
	public BuilderType mergeFrom(
	final InputStream input, final ExtensionRegistryLite extensionRegistry) throws IOException {
	final CodedInputStream codedInput = CodedInputStream.newInstance(input);
	mergeFrom(codedInput, extensionRegistry);
	codedInput.checkLastTagWas(0);
	return (BuilderType) this;
	}

	/**
	* An InputStream implementations which reads from some other InputStream but is limited to a
	* particular number of bytes. Used by mergeDelimitedFrom(). This is intentionally
	* package-private so that UnknownFieldSet can share it.
	*/
	static final class LimitedInputStream extends FilterInputStream {
	private int limit;

	LimitedInputStream(InputStream in, int limit) {
	super(in);
	this.limit = limit;
	}

	@Override
	public int available() throws IOException {
	return Math.min(super.available(), limit);
	}

	@Override
	public int read() throws IOException {
	if (limit <= 0) {
	return -1;
	}
	final int result = super.read();
	if (result >= 0) {
	--limit;
	}
	return result;
	}

	@Override
	public int read(final byte[] b, final int off, int len) throws IOException {
	if (limit <= 0) {
	return -1;
	}
	len = Math.min(len, limit);
	final int result = super.read(b, off, len);
	if (result >= 0) {
	limit -= result;
	}
	return result;
	}

	@Override
	public long skip(final long n) throws IOException {
	final long result = super.skip(Math.min(n, limit));
	if (result >= 0) {
	limit -= result;
	}
	return result;
	}
	}

	@Override
	public boolean mergeDelimitedFrom(
	final InputStream input, final ExtensionRegistryLite extensionRegistry) 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, extensionRegistry);
	return true;
	}

	@Override
	public boolean mergeDelimitedFrom(final InputStream input) throws IOException {
	return mergeDelimitedFrom(input, ExtensionRegistryLite.getEmptyRegistry());
	}

	@Override
	@SuppressWarnings("unchecked") // isInstance takes care of this
	public BuilderType mergeFrom(final MessageLite other) {
	if (!getDefaultInstanceForType().getClass().isInstance(other)) {
	throw new IllegalArgumentException(
	"mergeFrom(MessageLite) can only merge messages of the same type.");
	}

	return internalMergeFrom((MessageType) other);
	}

	protected abstract BuilderType internalMergeFrom(MessageType message);

	private String getReadingExceptionMessage(String target) {
	return "Reading "
	+ getClass().getName()
	+ " from a "
	+ target
	+ " threw an IOException (should never happen).";
	}

	// We check nulls as we iterate to avoid iterating over values twice.
	private static <T> void addAllCheckingNulls(Iterable<T> values, List<? super T> list) {
	if (list instanceof ArrayList && values instanceof Collection) {
	((ArrayList<T>) list).ensureCapacity(list.size() + ((Collection<T>) values).size());
	}
	int begin = list.size();
	for (T value : values) {
	if (value == null) {
	// encountered a null value so we must undo our modifications prior to throwing
	String message = "Element at index " + (list.size() - begin) + " is null.";
	for (int i = list.size() - 1; i >= begin; i--) {
	list.remove(i);
	}
	throw new NullPointerException(message);
	}
	list.add(value);
	}
	}

	/** Construct an UninitializedMessageException reporting missing fields in the given message. */
	protected static UninitializedMessageException newUninitializedMessageException(
	MessageLite message) {
	return new UninitializedMessageException(message);
	}

	// For binary compatibility.
	@Deprecated
	protected static <T> void addAll(final Iterable<T> values, final Collection<? super T> list) {
	addAll(values, (List<T>) list);
	}

	/**
	* Adds the {@code values} to the {@code list}. This is a helper method used by generated code.
	* Users should ignore it.
	*
	* @throws NullPointerException if {@code values} or any of the elements of {@code values} is
	* null.
	*/
	protected static <T> void addAll(final Iterable<T> values, final List<? super T> list) {
	checkNotNull(values);
	if (values instanceof LazyStringList) {
	// For StringOrByteStringLists, check the underlying elements to avoid
	// forcing conversions of ByteStrings to Strings.
	// TODO(dweis): Could we just prohibit nulls in all protobuf lists and get rid of this? Is
	// if even possible to hit this condition as all protobuf methods check for null first,
	// right?
	List<?> lazyValues = ((LazyStringList) values).getUnderlyingElements();
	LazyStringList lazyList = (LazyStringList) list;
	int begin = list.size();
	for (Object value : lazyValues) {
	if (value == null) {
	// encountered a null value so we must undo our modifications prior to throwing
	String message = "Element at index " + (lazyList.size() - begin) + " is null.";
	for (int i = lazyList.size() - 1; i >= begin; i--) {
	lazyList.remove(i);
	}
	throw new NullPointerException(message);
	}
	if (value instanceof ByteString) {
	lazyList.add((ByteString) value);
	} else {
	lazyList.add((String) value);
	}
	}
	} else {
	if (values instanceof PrimitiveNonBoxingCollection) {
	list.addAll((Collection<T>) values);
	} else {
	addAllCheckingNulls(values, list);
	}
	}
	}
	}
	}