content: /* Copyright (C) 2016-2018 Alibaba Group Holding Limited
  
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at
  
      http://www.apache.org/licenses/LICENSE-2.0
  
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  ==============================================================================*/
  
  // Protocol Buffers - Google's data interchange format
  // Copyright 2013 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.nano;
  
  import java.io.IOException;
  import java.nio.BufferOverflowException;
  import java.nio.ByteBuffer;
  import java.nio.ByteOrder;
  import java.nio.ReadOnlyBufferException;
  
  /**
   * Encodes and writes protocol message fields.
   *
   * <p>This class contains two kinds of methods:  methods that write specific
   * protocol message constructs and field types (e.g. {@link #writeTag} and
   * {@link #writeInt32}) and methods that write low-level values (e.g.
   * {@link #writeRawVarint32} and {@link #writeRawBytes}).  If you are
   * writing encoded protocol messages, you should use the former methods, but if
   * you are writing some other format of your own design, use the latter.
   *
   * <p>This class is totally unsynchronized.
   *
   * @author kneton@google.com Kenton Varda
   */
  public final class CodedOutputByteBufferNano {
    /* max bytes per java UTF-16 char in UTF-8 */
    private static final int MAX_UTF8_EXPANSION = 3;
    private final ByteBuffer buffer;
  
    private CodedOutputByteBufferNano(final byte[] buffer, final int offset,
                              final int length) {
      this(ByteBuffer.wrap(buffer, offset, length));
    }
  
    private CodedOutputByteBufferNano(final ByteBuffer buffer) {
      this.buffer = buffer;
      this.buffer.order(ByteOrder.LITTLE_ENDIAN);
    }
  
    /**
     * Create a new {@code CodedOutputStream} that writes directly to the given
     * byte array.  If more bytes are written than fit in the array,
     * {@link OutOfSpaceException} will be thrown.  Writing directly to a flat
     * array is faster than writing to an {@code OutputStream}.
     */
    public static CodedOutputByteBufferNano newInstance(final byte[] flatArray) {
      return newInstance(flatArray, 0, flatArray.length);
    }
  
    /**
     * Create a new {@code CodedOutputStream} that writes directly to the given
     * byte array slice.  If more bytes are written than fit in the slice,
     * {@link OutOfSpaceException} will be thrown.  Writing directly to a flat
     * array is faster than writing to an {@code OutputStream}.
     */
    public static CodedOutputByteBufferNano newInstance(final byte[] flatArray,
                                                final int offset,
                                                final int length) {
      return new CodedOutputByteBufferNano(flatArray, offset, length);
    }
  
    // -----------------------------------------------------------------
  
    /** Write a {@code double} field, including tag, to the stream. */
    public void writeDouble(final int fieldNumber, final double value)
                            throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_FIXED64);
      writeDoubleNoTag(value);
    }
  
    /** Write a {@code float} field, including tag, to the stream. */
    public void writeFloat(final int fieldNumber, final float value)
                           throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_FIXED32);
      writeFloatNoTag(value);
    }
  
    /** Write a {@code uint64} field, including tag, to the stream. */
    public void writeUInt64(final int fieldNumber, final long value)
                            throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_VARINT);
      writeUInt64NoTag(value);
    }
  
    /** Write an {@code int64} field, including tag, to the stream. */
    public void writeInt64(final int fieldNumber, final long value)
                           throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_VARINT);
      writeInt64NoTag(value);
    }
  
    /** Write an {@code int32} field, including tag, to the stream. */
    public void writeInt32(final int fieldNumber, final int value)
                           throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_VARINT);
      writeInt32NoTag(value);
    }
  
    /** Write a {@code fixed64} field, including tag, to the stream. */
    public void writeFixed64(final int fieldNumber, final long value)
                             throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_FIXED64);
      writeFixed64NoTag(value);
    }
  
    /** Write a {@code fixed32} field, including tag, to the stream. */
    public void writeFixed32(final int fieldNumber, final int value)
                             throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_FIXED32);
      writeFixed32NoTag(value);
    }
  
    /** Write a {@code bool} field, including tag, to the stream. */
    public void writeBool(final int fieldNumber, final boolean value)
                          throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_VARINT);
      writeBoolNoTag(value);
    }
  
    /** Write a {@code string} field, including tag, to the stream. */
    public void writeString(final int fieldNumber, final String value)
                            throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_LENGTH_DELIMITED);
      writeStringNoTag(value);
    }
  
    /** Write a {@code group} field, including tag, to the stream. */
    public void writeGroup(final int fieldNumber, final MessageNano value)
                           throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_START_GROUP);
      writeGroupNoTag(value);
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_END_GROUP);
    }
  
    /** Write an embedded message field, including tag, to the stream. */
    public void writeMessage(final int fieldNumber, final MessageNano value)
                             throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_LENGTH_DELIMITED);
      writeMessageNoTag(value);
    }
  
    /** Write a {@code bytes} field, including tag, to the stream. */
    public void writeBytes(final int fieldNumber, final byte[] value)
                           throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_LENGTH_DELIMITED);
      writeBytesNoTag(value);
    }
  
    /** Write a {@code uint32} field, including tag, to the stream. */
    public void writeUInt32(final int fieldNumber, final int value)
                            throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_VARINT);
      writeUInt32NoTag(value);
    }
  
    /**
     * Write an enum field, including tag, to the stream.  Caller is responsible
     * for converting the enum value to its numeric value.
     */
    public void writeEnum(final int fieldNumber, final int value)
                          throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_VARINT);
      writeEnumNoTag(value);
    }
  
    /** Write an {@code sfixed32} field, including tag, to the stream. */
    public void writeSFixed32(final int fieldNumber, final int value)
                              throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_FIXED32);
      writeSFixed32NoTag(value);
    }
  
    /** Write an {@code sfixed64} field, including tag, to the stream. */
    public void writeSFixed64(final int fieldNumber, final long value)
                              throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_FIXED64);
      writeSFixed64NoTag(value);
    }
  
    /** Write an {@code sint32} field, including tag, to the stream. */
    public void writeSInt32(final int fieldNumber, final int value)
                            throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_VARINT);
      writeSInt32NoTag(value);
    }
  
    /** Write an {@code sint64} field, including tag, to the stream. */
    public void writeSInt64(final int fieldNumber, final long value)
                            throws IOException {
      writeTag(fieldNumber, WireFormatNano.WIRETYPE_VARINT);
      writeSInt64NoTag(value);
    }
  
    /**
     * Write a MessageSet extension field to the stream.  For historical reasons,
     * the wire format differs from normal fields.
     */
  //  public void writeMessageSetExtension(final int fieldNumber,
  //                                       final MessageMicro value)
  //                                       throws IOException {
  //    writeTag(WireFormatMicro.MESSAGE_SET_ITEM, WireFormatMicro.WIRETYPE_START_GROUP);
  //    writeUInt32(WireFormatMicro.MESSAGE_SET_TYPE_ID, fieldNumber);
  //    writeMessage(WireFormatMicro.MESSAGE_SET_MESSAGE, value);
  //    writeTag(WireFormatMicro.MESSAGE_SET_ITEM, WireFormatMicro.WIRETYPE_END_GROUP);
  //  }
  
    /**
     * Write an unparsed MessageSet extension field to the stream.  For
     * historical reasons, the wire format differs from normal fields.
     */
  //  public void writeRawMessageSetExtension(final int fieldNumber,
  //                                          final ByteStringMicro value)
  //                                          throws IOException {
  //    writeTag(WireFormatMicro.MESSAGE_SET_ITEM, WireFormatMicro.WIRETYPE_START_GROUP);
  //    writeUInt32(WireFormatMicro.MESSAGE_SET_TYPE_ID, fieldNumber);
  //    writeBytes(WireFormatMicro.MESSAGE_SET_MESSAGE, value);
  //    writeTag(WireFormatMicro.MESSAGE_SET_ITEM, WireFormatMicro.WIRETYPE_END_GROUP);
  //  }
  
    // -----------------------------------------------------------------
  
    /** Write a {@code double} field to the stream. */
    public void writeDoubleNoTag(final double value) throws IOException {
      writeRawLittleEndian64(Double.doubleToLongBits(value));
    }
  
    /** Write a {@code float} field to the stream. */
    public void writeFloatNoTag(final float value) throws IOException {
      writeRawLittleEndian32(Float.floatToIntBits(value));
    }
  
    /** Write a {@code uint64} field to the stream. */
    public void writeUInt64NoTag(final long value) throws IOException {
      writeRawVarint64(value);
    }
  
    /** Write an {@code int64} field to the stream. */
    public void writeInt64NoTag(final long value) throws IOException {
      writeRawVarint64(value);
    }
  
    /** Write an {@code int32} field to the stream. */
    public void writeInt32NoTag(final int value) throws IOException {
      if (value >= 0) {
        writeRawVarint32(value);
      } else {
        // Must sign-extend.
        writeRawVarint64(value);
      }
    }
  
    /** Write a {@code fixed64} field to the stream. */
    public void writeFixed64NoTag(final long value) throws IOException {
      writeRawLittleEndian64(value);
    }
  
    /** Write a {@code fixed32} field to the stream. */
    public void writeFixed32NoTag(final int value) throws IOException {
      writeRawLittleEndian32(value);
    }
  
    /** Write a {@code bool} field to the stream. */
    public void writeBoolNoTag(final boolean value) throws IOException {
      writeRawByte(value ? 1 : 0);
    }
  
    /** Write a {@code string} field to the stream. */
    public void writeStringNoTag(final String value) throws IOException {
      // UTF-8 byte length of the string is at least its UTF-16 code unit length (value.length()),
      // and at most 3 times of it. Optimize for the case where we know this length results in a
      // constant varint length - saves measuring length of the string.
      try {
        final int minLengthVarIntSize = computeRawVarint32Size(value.length());
        final int maxLengthVarIntSize = computeRawVarint32Size(value.length() * MAX_UTF8_EXPANSION);
        if (minLengthVarIntSize == maxLengthVarIntSize) {
          int oldPosition = buffer.position();
          // Buffer.position, when passed a position that is past its limit, throws
          // IllegalArgumentException, and this class is documented to throw
          // OutOfSpaceException instead.
          if (buffer.remaining() < minLengthVarIntSize) {
            throw new OutOfSpaceException(oldPosition + minLengthVarIntSize, buffer.limit());
          }
          buffer.position(oldPosition + minLengthVarIntSize);
          encode(value, buffer);
          int newPosition = buffer.position();
          buffer.position(oldPosition);
          writeRawVarint32(newPosition - oldPosition - minLengthVarIntSize);
          buffer.position(newPosition);
        } else {
          writeRawVarint32(encodedLength(value));
          encode(value, buffer);
        }
      } catch (BufferOverflowException e) {
        final OutOfSpaceException outOfSpaceException = new OutOfSpaceException(buffer.position(),
            buffer.limit());
        outOfSpaceException.initCause(e);
        throw outOfSpaceException;
      }
    }
  
    // These UTF-8 handling methods are copied from Guava's Utf8 class.
    /**
     * Returns the number of bytes in the UTF-8-encoded form of {@code sequence}. For a string,
     * this method is equivalent to {@code string.getBytes(UTF_8).length}, but is more efficient in
     * both time and space.
     *
     * @throws IllegalArgumentException if {@code sequence} contains ill-formed UTF-16 (unpaired
     *     surrogates)
     */
    private static int encodedLength(CharSequence sequence) {
      // Warning to maintainers: this implementation is highly optimized.
      int utf16Length = sequence.length();
      int utf8Length = utf16Length;
      int i = 0;
  
      // This loop optimizes for pure ASCII.
      while (i < utf16Length && sequence.charAt(i) < 0x80) {
        i++;
      }
  
      // This loop optimizes for chars less than 0x800.
      for (; i < utf16Length; i++) {
        char c = sequence.charAt(i);
        if (c < 0x800) {
          utf8Length += ((0x7f - c) >>> 31);  // branch free!
        } else {
          utf8Length += encodedLengthGeneral(sequence, i);
          break;
        }
      }
  
      if (utf8Length < utf16Length) {
        // Necessary and sufficient condition for overflow because of maximum 3x expansion
        throw new IllegalArgumentException("UTF-8 length does not fit in int: "
                + (utf8Length + (1L << 32)));
      }
      return utf8Length;
    }
  
    private static int encodedLengthGeneral(CharSequence sequence, int start) {
      int utf16Length = sequence.length();
      int utf8Length = 0;
      for (int i = start; i < utf16Length; i++) {
        char c = sequence.charAt(i);
        if (c < 0x800) {
          utf8Length += (0x7f - c) >>> 31; // branch free!
        } else {
          utf8Length += 2;
          // jdk7+: if (Character.isSurrogate(c)) {
          if (Character.MIN_SURROGATE <= c && c <= Character.MAX_SURROGATE) {
            // Check that we have a well-formed surrogate pair.
            int cp = Character.codePointAt(sequence, i);
            if (cp < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
              throw new IllegalArgumentException("Unpaired surrogate at index " + i);
            }
            i++;
          }
        }
      }
      return utf8Length;
    }
  
    /**
     * Encodes {@code sequence} into UTF-8, in {@code byteBuffer}. For a string, this method is
     * equivalent to {@code buffer.put(string.getBytes(UTF_8))}, but is more efficient in both time
     * and space. Bytes are written starting at the current position. This method requires paired
     * surrogates, and therefore does not support chunking.
     *
     * <p>To ensure sufficient space in the output buffer, either call {@link #encodedLength} to
     * compute the exact amount needed, or leave room for {@code 3 * sequence.length()}, which is the
     * largest possible number of bytes that any input can be encoded to.
     *
     * @throws IllegalArgumentException if {@code sequence} contains ill-formed UTF-16 (unpaired
     *     surrogates)
     * @throws BufferOverflowException if {@code sequence} encoded in UTF-8 does not fit in
     *     {@code byteBuffer}'s remaining space.
     * @throws ReadOnlyBufferException if {@code byteBuffer} is a read-only buffer.
     */
    private static void encode(CharSequence sequence, ByteBuffer byteBuffer) {
      if (byteBuffer.isReadOnly()) {
        throw new ReadOnlyBufferException();
      } else if (byteBuffer.hasArray()) {
        try {
          int encoded = encode(sequence,
                  byteBuffer.array(),
                  byteBuffer.arrayOffset() + byteBuffer.position(),
                  byteBuffer.remaining());
          byteBuffer.position(encoded - byteBuffer.arrayOffset());
        } catch (ArrayIndexOutOfBoundsException e) {
          BufferOverflowException boe = new BufferOverflowException();
          boe.initCause(e);
          throw boe;
        }
      } else {
        encodeDirect(sequence, byteBuffer);
      }
    }
  
    private static void encodeDirect(CharSequence sequence, ByteBuffer byteBuffer) {
      int utf16Length = sequence.length();
      for (int i = 0; i < utf16Length; i++) {
        final char c = sequence.charAt(i);
        if (c < 0x80) { // ASCII
          byteBuffer.put((byte) c);
        } else if (c < 0x800) { // 11 bits, two UTF-8 bytes
          byteBuffer.put((byte) ((0xF << 6) | (c >>> 6)));
          byteBuffer.put((byte) (0x80 | (0x3F & c)));
        } else if (c < Character.MIN_SURROGATE || Character.MAX_SURROGATE < c) {
          // Maximium single-char code point is 0xFFFF, 16 bits, three UTF-8 bytes
          byteBuffer.put((byte) ((0xF << 5) | (c >>> 12)));
          byteBuffer.put((byte) (0x80 | (0x3F & (c >>> 6))));
          byteBuffer.put((byte) (0x80 | (0x3F & c)));
        } else {
          final char low;
          if (i + 1 == sequence.length()
                  || !Character.isSurrogatePair(c, (low = sequence.charAt(++i)))) {
            throw new IllegalArgumentException("Unpaired surrogate at index " + (i - 1));
          }
          int codePoint = Character.toCodePoint(c, low);
          byteBuffer.put((byte) ((0xF << 4) | (codePoint >>> 18)));
          byteBuffer.put((byte) (0x80 | (0x3F & (codePoint >>> 12))));
          byteBuffer.put((byte) (0x80 | (0x3F & (codePoint >>> 6))));
          byteBuffer.put((byte) (0x80 | (0x3F & codePoint)));
        }
      }
    }
  
    private static int encode(CharSequence sequence, byte[] bytes, int offset, int length) {
      int utf16Length = sequence.length();
      int j = offset;
      int i = 0;
      int limit = offset + length;
      // Designed to take advantage of
      // https://wikis.oracle.com/display/HotSpotInternals/RangeCheckElimination
      for (char c; i < utf16Length && i + j < limit && (c = sequence.charAt(i)) < 0x80; i++) {
        bytes[j + i] = (byte) c;
      }
      if (i == utf16Length) {
        return j + utf16Length;
      }
      j += i;
      for (char c; i < utf16Length; i++) {
        c = sequence.charAt(i);
        if (c < 0x80 && j < limit) {
          bytes[j++] = (byte) c;
        } else if (c < 0x800 && j <= limit - 2) { // 11 bits, two UTF-8 bytes
          bytes[j++] = (byte) ((0xF << 6) | (c >>> 6));
          bytes[j++] = (byte) (0x80 | (0x3F & c));
        } else if ((c < Character.MIN_SURROGATE || Character.MAX_SURROGATE < c) && j <= limit - 3) {
          // Maximum single-char code point is 0xFFFF, 16 bits, three UTF-8 bytes
          bytes[j++] = (byte) ((0xF << 5) | (c >>> 12));
          bytes[j++] = (byte) (0x80 | (0x3F & (c >>> 6)));
          bytes[j++] = (byte) (0x80 | (0x3F & c));
        } else if (j <= limit - 4) {
          // Minimum code point represented by a surrogate pair is 0x10000, 17 bits, four UTF-8 bytes
          final char low;
          if (i + 1 == sequence.length()
                  || !Character.isSurrogatePair(c, (low = sequence.charAt(++i)))) {
            throw new IllegalArgumentException("Unpaired surrogate at index " + (i - 1));
          }
          int codePoint = Character.toCodePoint(c, low);
          bytes[j++] = (byte) ((0xF << 4) | (codePoint >>> 18));
          bytes[j++] = (byte) (0x80 | (0x3F & (codePoint >>> 12)));
          bytes[j++] = (byte) (0x80 | (0x3F & (codePoint >>> 6)));
          bytes[j++] = (byte) (0x80 | (0x3F & codePoint));
        } else {
          throw new ArrayIndexOutOfBoundsException("Failed writing " + c + " at index " + j);
        }
      }
      return j;
    }
  
    // End guava UTF-8 methods
  
  
    /** Write a {@code group} field to the stream. */
    public void writeGroupNoTag(final MessageNano value) throws IOException {
      value.writeTo(this);
    }
  
    /** Write an embedded message field to the stream. */
    public void writeMessageNoTag(final MessageNano value) throws IOException {
      writeRawVarint32(value.getCachedSize());
      value.writeTo(this);
    }
  
    /** Write a {@code bytes} field to the stream. */
    public void writeBytesNoTag(final byte[] value) throws IOException {
      writeRawVarint32(value.length);
      writeRawBytes(value);
    }
  
    /** Write a {@code uint32} field to the stream. */
    public void writeUInt32NoTag(final int value) throws IOException {
      writeRawVarint32(value);
    }
  
    /**
     * Write an enum field to the stream.  Caller is responsible
     * for converting the enum value to its numeric value.
     */
    public void writeEnumNoTag(final int value) throws IOException {
      writeRawVarint32(value);
    }
  
    /** Write an {@code sfixed32} field to the stream. */
    public void writeSFixed32NoTag(final int value) throws IOException {
      writeRawLittleEndian32(value);
    }
  
    /** Write an {@code sfixed64} field to the stream. */
    public void writeSFixed64NoTag(final long value) throws IOException {
      writeRawLittleEndian64(value);
    }
  
    /** Write an {@code sint32} field to the stream. */
    public void writeSInt32NoTag(final int value) throws IOException {
      writeRawVarint32(encodeZigZag32(value));
    }
  
    /** Write an {@code sint64} field to the stream. */
    public void writeSInt64NoTag(final long value) throws IOException {
      writeRawVarint64(encodeZigZag64(value));
    }
  
    // =================================================================
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code double} field, including tag.
     */
    public static int computeDoubleSize(final int fieldNumber,
                                        final double value) {
      return computeTagSize(fieldNumber) + computeDoubleSizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code float} field, including tag.
     */
    public static int computeFloatSize(final int fieldNumber, final float value) {
      return computeTagSize(fieldNumber) + computeFloatSizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code uint64} field, including tag.
     */
    public static int computeUInt64Size(final int fieldNumber, final long value) {
      return computeTagSize(fieldNumber) + computeUInt64SizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode an
     * {@code int64} field, including tag.
     */
    public static int computeInt64Size(final int fieldNumber, final long value) {
      return computeTagSize(fieldNumber) + computeInt64SizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode an
     * {@code int32} field, including tag.
     */
    public static int computeInt32Size(final int fieldNumber, final int value) {
      return computeTagSize(fieldNumber) + computeInt32SizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code fixed64} field, including tag.
     */
    public static int computeFixed64Size(final int fieldNumber,
                                         final long value) {
      return computeTagSize(fieldNumber) + computeFixed64SizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code fixed32} field, including tag.
     */
    public static int computeFixed32Size(final int fieldNumber,
                                         final int value) {
      return computeTagSize(fieldNumber) + computeFixed32SizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code bool} field, including tag.
     */
    public static int computeBoolSize(final int fieldNumber,
                                      final boolean value) {
      return computeTagSize(fieldNumber) + computeBoolSizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code string} field, including tag.
     */
    public static int computeStringSize(final int fieldNumber,
                                        final String value) {
      return computeTagSize(fieldNumber) + computeStringSizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code group} field, including tag.
     */
    public static int computeGroupSize(final int fieldNumber,
                                       final MessageNano value) {
      return computeTagSize(fieldNumber) * 2 + computeGroupSizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode an
     * embedded message field, including tag.
     */
    public static int computeMessageSize(final int fieldNumber,
                                         final MessageNano value) {
      return computeTagSize(fieldNumber) + computeMessageSizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code bytes} field, including tag.
     */
    public static int computeBytesSize(final int fieldNumber,
                                       final byte[] value) {
      return computeTagSize(fieldNumber) + computeBytesSizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code uint32} field, including tag.
     */
    public static int computeUInt32Size(final int fieldNumber, final int value) {
      return computeTagSize(fieldNumber) + computeUInt32SizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode an
     * enum field, including tag.  Caller is responsible for converting the
     * enum value to its numeric value.
     */
    public static int computeEnumSize(final int fieldNumber, final int value) {
      return computeTagSize(fieldNumber) + computeEnumSizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode an
     * {@code sfixed32} field, including tag.
     */
    public static int computeSFixed32Size(final int fieldNumber,
                                          final int value) {
      return computeTagSize(fieldNumber) + computeSFixed32SizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode an
     * {@code sfixed64} field, including tag.
     */
    public static int computeSFixed64Size(final int fieldNumber,
                                          final long value) {
      return computeTagSize(fieldNumber) + computeSFixed64SizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode an
     * {@code sint32} field, including tag.
     */
    public static int computeSInt32Size(final int fieldNumber, final int value) {
      return computeTagSize(fieldNumber) + computeSInt32SizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode an
     * {@code sint64} field, including tag.
     */
    public static int computeSInt64Size(final int fieldNumber, final long value) {
      return computeTagSize(fieldNumber) + computeSInt64SizeNoTag(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * MessageSet extension to the stream.  For historical reasons,
     * the wire format differs from normal fields.
     */
  //  public static int computeMessageSetExtensionSize(
  //      final int fieldNumber, final MessageMicro value) {
  //    return computeTagSize(WireFormatMicro.MESSAGE_SET_ITEM) * 2 +
  //           computeUInt32Size(WireFormatMicro.MESSAGE_SET_TYPE_ID, fieldNumber) +
  //           computeMessageSize(WireFormatMicro.MESSAGE_SET_MESSAGE, value);
  //  }
  
    /**
     * Compute the number of bytes that would be needed to encode an
     * unparsed MessageSet extension field to the stream.  For
     * historical reasons, the wire format differs from normal fields.
     */
  //  public static int computeRawMessageSetExtensionSize(
  //      final int fieldNumber, final ByteStringMicro value) {
  //    return computeTagSize(WireFormatMicro.MESSAGE_SET_ITEM) * 2 +
  //           computeUInt32Size(WireFormatMicro.MESSAGE_SET_TYPE_ID, fieldNumber) +
  //           computeBytesSize(WireFormatMicro.MESSAGE_SET_MESSAGE, value);
  //  }
  
    // -----------------------------------------------------------------
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code double} field, including tag.
     */
    public static int computeDoubleSizeNoTag(final double value) {
      return LITTLE_ENDIAN_64_SIZE;
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code float} field, including tag.
     */
    public static int computeFloatSizeNoTag(final float value) {
      return LITTLE_ENDIAN_32_SIZE;
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code uint64} field, including tag.
     */
    public static int computeUInt64SizeNoTag(final long value) {
      return computeRawVarint64Size(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode an
     * {@code int64} field, including tag.
     */
    public static int computeInt64SizeNoTag(final long value) {
      return computeRawVarint64Size(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode an
     * {@code int32} field, including tag.
     */
    public static int computeInt32SizeNoTag(final int value) {
      if (value >= 0) {
        return computeRawVarint32Size(value);
      } else {
        // Must sign-extend.
        return 10;
      }
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code fixed64} field.
     */
    public static int computeFixed64SizeNoTag(final long value) {
      return LITTLE_ENDIAN_64_SIZE;
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code fixed32} field.
     */
    public static int computeFixed32SizeNoTag(final int value) {
      return LITTLE_ENDIAN_32_SIZE;
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code bool} field.
     */
    public static int computeBoolSizeNoTag(final boolean value) {
      return 1;
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code string} field.
     */
    public static int computeStringSizeNoTag(final String value) {
      final int length = encodedLength(value);
      return computeRawVarint32Size(length) + length;
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code group} field.
     */
    public static int computeGroupSizeNoTag(final MessageNano value) {
      return value.getSerializedSize();
    }
  
    /**
     * Compute the number of bytes that would be needed to encode an embedded
     * message field.
     */
    public static int computeMessageSizeNoTag(final MessageNano value) {
      final int size = value.getSerializedSize();
      return computeRawVarint32Size(size) + size;
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code bytes} field.
     */
    public static int computeBytesSizeNoTag(final byte[] value) {
      return computeRawVarint32Size(value.length) + value.length;
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a
     * {@code uint32} field.
     */
    public static int computeUInt32SizeNoTag(final int value) {
      return computeRawVarint32Size(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode an enum field.
     * Caller is responsible for converting the enum value to its numeric value.
     */
    public static int computeEnumSizeNoTag(final int value) {
      return computeRawVarint32Size(value);
    }
  
    /**
     * Compute the number of bytes that would be needed to encode an
     * {@code sfixed32} field.
     */
    public static int computeSFixed32SizeNoTag(final int value) {
      return LITTLE_ENDIAN_32_SIZE;
    }
  
    /**
     * Compute the number of bytes that would be needed to encode an
     * {@code sfixed64} field.
     */
    public static int computeSFixed64SizeNoTag(final long value) {
      return LITTLE_ENDIAN_64_SIZE;
    }
  
    /**
     * Compute the number of bytes that would be needed to encode an
     * {@code sint32} field.
     */
    public static int computeSInt32SizeNoTag(final int value) {
      return computeRawVarint32Size(encodeZigZag32(value));
    }
  
    /**
     * Compute the number of bytes that would be needed to encode an
     * {@code sint64} field.
     */
    public static int computeSInt64SizeNoTag(final long value) {
      return computeRawVarint64Size(encodeZigZag64(value));
    }
  
    // =================================================================
  
    /**
     * If writing to a flat array, return the space left in the array.
     * Otherwise, throws {@code UnsupportedOperationException}.
     */
    public int spaceLeft() {
      return buffer.remaining();
    }
  
    /**
     * Verifies that {@link #spaceLeft()} returns zero.  It's common to create
     * a byte array that is exactly big enough to hold a message, then write to
     * it with a {@code CodedOutputStream}.  Calling {@code checkNoSpaceLeft()}
     * after writing verifies that the message was actually as big as expected,
     * which can help catch bugs.
     */
    public void checkNoSpaceLeft() {
      if (spaceLeft() != 0) {
        throw new IllegalStateException(
          "Did not write as much data as expected.");
      }
    }
  
    /**
     * Returns the position within the internal buffer.
     */
    public int position() {
      return buffer.position();
    }
  
    /**
     * Resets the position within the internal buffer to zero.
     *
     * @see #position
     * @see #spaceLeft
     */
    public void reset() {
      buffer.clear();
    }
  
    /**
     * If you create a CodedOutputStream around a simple flat array, you must
     * not attempt to write more bytes than the array has space.  Otherwise,
     * this exception will be thrown.
     */
    public static class OutOfSpaceException extends IOException {
      private static final long serialVersionUID = -6947486886997889499L;
  
      OutOfSpaceException(int position, int limit) {
        super("CodedOutputStream was writing to a flat byte array and ran " +
              "out of space (pos " + position + " limit " + limit + ").");
      }
    }
  
    /** Write a single byte. */
    public void writeRawByte(final byte value) throws IOException {
      if (!buffer.hasRemaining()) {
        // We're writing to a single buffer.
        throw new OutOfSpaceException(buffer.position(), buffer.limit());
      }
  
      buffer.put(value);
    }
  
    /** Write a single byte, represented by an integer value. */
    public void writeRawByte(final int value) throws IOException {
      writeRawByte((byte) value);
    }
  
    /** Write an array of bytes. */
    public void writeRawBytes(final byte[] value) throws IOException {
      writeRawBytes(value, 0, value.length);
    }
  
    /** Write part of an array of bytes. */
    public void writeRawBytes(final byte[] value, int offset, int length)
                              throws IOException {
      if (buffer.remaining() >= length) {
        buffer.put(value, offset, length);
      } else {
        // We're writing to a single buffer.
        throw new OutOfSpaceException(buffer.position(), buffer.limit());
      }
    }
  
    /** Encode and write a tag. */
    public void writeTag(final int fieldNumber, final int wireType)
                         throws IOException {
      writeRawVarint32(WireFormatNano.makeTag(fieldNumber, wireType));
    }
  
    /** Compute the number of bytes that would be needed to encode a tag. */
    public static int computeTagSize(final int fieldNumber) {
      return computeRawVarint32Size(WireFormatNano.makeTag(fieldNumber, 0));
    }
  
    /**
     * Encode and write a varint.  {@code value} is treated as
     * unsigned, so it won't be sign-extended if negative.
     */
    public void writeRawVarint32(int value) throws IOException {
      while (true) {
        if ((value & ~0x7F) == 0) {
          writeRawByte(value);
          return;
        } else {
          writeRawByte((value & 0x7F) | 0x80);
          value >>>= 7;
        }
      }
    }
  
    /**
     * Compute the number of bytes that would be needed to encode a varint.
     * {@code value} is treated as unsigned, so it won't be sign-extended if
     * negative.
     */
    public static int computeRawVarint32Size(final int value) {
      if ((value & (0xffffffff <<  7)) == 0) return 1;
      if ((value & (0xffffffff << 14)) == 0) return 2;
      if ((value & (0xffffffff << 21)) == 0) return 3;
      if ((value & (0xffffffff << 28)) == 0) return 4;
      return 5;
    }
  
    /** Encode and write a varint. */
    public void writeRawVarint64(long value) throws IOException {
      while (true) {
        if ((value & ~0x7FL) == 0) {
          writeRawByte((int)value);
          return;
        } else {
          writeRawByte(((int)value & 0x7F) | 0x80);
          value >>>= 7;
        }
      }
    }
  
    /** Compute the number of bytes that would be needed to encode a varint. */
    public static int computeRawVarint64Size(final long value) {
      if ((value & (0xffffffffffffffffL <<  7)) == 0) return 1;
      if ((value & (0xffffffffffffffffL << 14)) == 0) return 2;
      if ((value & (0xffffffffffffffffL << 21)) == 0) return 3;
      if ((value & (0xffffffffffffffffL << 28)) == 0) return 4;
      if ((value & (0xffffffffffffffffL << 35)) == 0) return 5;
      if ((value & (0xffffffffffffffffL << 42)) == 0) return 6;
      if ((value & (0xffffffffffffffffL << 49)) == 0) return 7;
      if ((value & (0xffffffffffffffffL << 56)) == 0) return 8;
      if ((value & (0xffffffffffffffffL << 63)) == 0) return 9;
      return 10;
    }
  
    /** Write a little-endian 32-bit integer. */
    public void writeRawLittleEndian32(final int value) throws IOException {
      if (buffer.remaining() < 4) {
        throw new OutOfSpaceException(buffer.position(), buffer.limit());
      }
      buffer.putInt(value);
    }
  
    public static final int LITTLE_ENDIAN_32_SIZE = 4;
  
    /** Write a little-endian 64-bit integer. */
    public void writeRawLittleEndian64(final long value) throws IOException {
      if (buffer.remaining() < 8) {
        throw new OutOfSpaceException(buffer.position(), buffer.limit());
      }
      buffer.putLong(value);
    }
  
    public static final int LITTLE_ENDIAN_64_SIZE = 8;
  
    /**
     * Encode a ZigZag-encoded 32-bit value.  ZigZag encodes signed integers
     * into values that can be efficiently encoded with varint.  (Otherwise,
     * negative values must be sign-extended to 64 bits to be varint encoded,
     * thus always taking 10 bytes on the wire.)
     *
     * @param n A signed 32-bit integer.
     * @return An unsigned 32-bit integer, stored in a signed int because
     *         Java has no explicit unsigned support.
     */
    public static int encodeZigZag32(final int n) {
      // Note:  the right-shift must be arithmetic
      return (n << 1) ^ (n >> 31);
    }
  
    /**
     * Encode a ZigZag-encoded 64-bit value.  ZigZag encodes signed integers
     * into values that can be efficiently encoded with varint.  (Otherwise,
     * negative values must be sign-extended to 64 bits to be varint encoded,
     * thus always taking 10 bytes on the wire.)
     *
     * @param n A signed 64-bit integer.
     * @return An unsigned 64-bit integer, stored in a signed int because
     *         Java has no explicit unsigned support.
     */
    public static long encodeZigZag64(final long n) {
      // Note:  the right-shift must be arithmetic
      return (n << 1) ^ (n >> 63);
    }
  
    static int computeFieldSize(int number, int type, Object object) {
      switch (type) {
        case InternalNano.TYPE_BOOL:
          return computeBoolSize(number, (Boolean) object);
        case InternalNano.TYPE_BYTES:
          return computeBytesSize(number, (byte[]) object);
        case InternalNano.TYPE_STRING:
          return computeStringSize(number, (String) object);
        case InternalNano.TYPE_FLOAT:
          return computeFloatSize(number, (Float) object);
        case InternalNano.TYPE_DOUBLE:
          return computeDoubleSize(number, (Double) object);
        case InternalNano.TYPE_ENUM:
          return computeEnumSize(number, (Integer) object);
        case InternalNano.TYPE_FIXED32:
          return computeFixed32Size(number, (Integer) object);
        case InternalNano.TYPE_INT32:
          return computeInt32Size(number, (Integer) object);
        case InternalNano.TYPE_UINT32:
          return computeUInt32Size(number, (Integer) object);
        case InternalNano.TYPE_SINT32:
          return computeSInt32Size(number, (Integer) object);
        case InternalNano.TYPE_SFIXED32:
          return computeSFixed32Size(number, (Integer) object);
        case InternalNano.TYPE_INT64:
          return computeInt64Size(number, (Long) object);
        case InternalNano.TYPE_UINT64:
          return computeUInt64Size(number, (Long) object);
        case InternalNano.TYPE_SINT64:
          return computeSInt64Size(number, (Long) object);
        case InternalNano.TYPE_FIXED64:
          return computeFixed64Size(number, (Long) object);
        case InternalNano.TYPE_SFIXED64:
          return computeSFixed64Size(number, (Long) object);
        case InternalNano.TYPE_MESSAGE:
          return computeMessageSize(number, (MessageNano) object);
        case InternalNano.TYPE_GROUP:
          return computeGroupSize(number, (MessageNano) object);
        default:
          throw new IllegalArgumentException("Unknown type: " + type);
      }
    }
  
    void writeField(int number, int type, Object value)
        throws IOException {
      switch (type) {
        case InternalNano.TYPE_DOUBLE:
          Double doubleValue = (Double) value;
          writeDouble(number, doubleValue);
          break;
        case InternalNano.TYPE_FLOAT:
          Float floatValue = (Float) value;
          writeFloat(number, floatValue);
          break;
        case InternalNano.TYPE_INT64:
          Long int64Value = (Long) value;
          writeInt64(number, int64Value);
          break;
        case InternalNano.TYPE_UINT64:
          Long uint64Value = (Long) value;
          writeUInt64(number, uint64Value);
          break;
        case InternalNano.TYPE_INT32:
          Integer int32Value = (Integer) value;
          writeInt32(number, int32Value);
          break;
        case InternalNano.TYPE_FIXED64:
          Long fixed64Value = (Long) value;
          writeFixed64(number, fixed64Value);
          break;
        case InternalNano.TYPE_FIXED32:
          Integer fixed32Value = (Integer) value;
          writeFixed32(number, fixed32Value);
          break;
        case InternalNano.TYPE_BOOL:
          Boolean boolValue = (Boolean) value;
          writeBool(number, boolValue);
          break;
        case InternalNano.TYPE_STRING:
          String stringValue = (String) value;
          writeString(number, stringValue);
          break;
        case InternalNano.TYPE_BYTES:
          byte[] bytesValue = (byte[]) value;
          writeBytes(number, bytesValue);
          break;
        case InternalNano.TYPE_UINT32:
          Integer uint32Value = (Integer) value;
          writeUInt32(number, uint32Value);
          break;
        case InternalNano.TYPE_ENUM:
          Integer enumValue = (Integer) value;
          writeEnum(number, enumValue);
          break;
        case InternalNano.TYPE_SFIXED32:
          Integer sfixed32Value = (Integer) value;
          writeSFixed32(number, sfixed32Value);
          break;
        case InternalNano.TYPE_SFIXED64:
          Long sfixed64Value = (Long) value;
          writeSFixed64(number, sfixed64Value);
          break;
        case InternalNano.TYPE_SINT32:
          Integer sint32Value = (Integer) value;
          writeSInt32(number, sint32Value);
          break;
        case InternalNano.TYPE_SINT64:
          Long sint64Value = (Long) value;
          writeSInt64(number, sint64Value);
          break;
        case InternalNano.TYPE_MESSAGE:
          MessageNano messageValue = (MessageNano) value;
          writeMessage(number, messageValue);
          break;
        case InternalNano.TYPE_GROUP:
          MessageNano groupValue = (MessageNano) value;
          writeGroup(number, groupValue);
          break;
        default:
          throw new IOException("Unknown type: " + type);
      }
    }
  
  }
  