content: // 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 java.io.FilterInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.Collection;
  
  /**
   * 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();
    }
  
  
    /**
     * 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.");
      }
    }
  
    protected static <T> void addAll(final Iterable<T> values,
        final Collection<? 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).";
      }
  
      /**
       * Construct an UninitializedMessageException reporting missing fields in
       * the given message.
       */
      protected static UninitializedMessageException
          newUninitializedMessageException(MessageLite message) {
        return new UninitializedMessageException(message);
      }
  
      /**
       * 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. When that happens, some elements of
       * {@code values} may have already been added to the result {@code list}.
       */
      protected static <T> void addAll(final Iterable<T> values,
                                       final Collection<? super T> list) {
        if (values == null) {
          throw new NullPointerException();
        }
        if (values instanceof LazyStringList) {
          // For StringOrByteStringLists, check the underlying elements to avoid
          // forcing conversions of ByteStrings to Strings.
          checkForNullValues(((LazyStringList) values).getUnderlyingElements());
          list.addAll((Collection<T>) values);
        } else if (values instanceof Collection) {
          checkForNullValues(values);
          list.addAll((Collection<T>) values);
        } else {
          for (final T value : values) {
            if (value == null) {
              throw new NullPointerException();
            }
            list.add(value);
          }
        }
      }
  
      private static void checkForNullValues(final Iterable<?> values) {
        for (final Object value : values) {
          if (value == null) {
            throw new NullPointerException();
          }
        }
      }
    }
  }
  