down integrate to svn

1 files changed, 208 insertions, 22 deletions

diff --git a/java/src/main/java/com/google/protobuf/CodedOutputStream.java b/java/src/main/java/com/google/protobuf/CodedOutputStream.java
index ca24638d..0f232071 100644
--- a/java/src/main/java/com/google/protobuf/CodedOutputStream.java
+++ b/java/src/main/java/com/google/protobuf/CodedOutputStream.java
@@ -31,9 +31,9 @@
 package com.google.protobuf;
 
 import java.io.IOException;
-import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.UnsupportedEncodingException;
+import java.nio.ByteBuffer;
 
 /**
  * Encodes and writes protocol message fields.
@@ -53,6 +53,7 @@ public final class CodedOutputStream {
   private final byte[] buffer;
   private final int limit;
   private int position;
+  private int totalBytesWritten = 0;
 
   private final OutputStream output;
 
@@ -129,6 +130,38 @@ public final class CodedOutputStream {
     return new CodedOutputStream(flatArray, offset, length);
   }
 
+  /**
+   * Create a new {@code CodedOutputStream} that writes to the given ByteBuffer.
+   */
+  public static CodedOutputStream newInstance(ByteBuffer byteBuffer) {
+    return newInstance(byteBuffer, DEFAULT_BUFFER_SIZE);
+  }
+
+  /**
+   * Create a new {@code CodedOutputStream} that writes to the given ByteBuffer.
+   */
+  public static CodedOutputStream newInstance(ByteBuffer byteBuffer,
+      int bufferSize) {
+    return newInstance(new ByteBufferOutputStream(byteBuffer), bufferSize);
+  }
+  
+  private static class ByteBufferOutputStream extends OutputStream {
+    private final ByteBuffer byteBuffer;
+    public ByteBufferOutputStream(ByteBuffer byteBuffer) {
+      this.byteBuffer = byteBuffer;
+    }
+
+    @Override
+    public void write(int b) throws IOException {
+      byteBuffer.put((byte) b);
+    }
+
+    @Override
+    public void write(byte[] data, int offset, int length) throws IOException {
+      byteBuffer.put(data, offset, length);
+    }
+  }
+
   // -----------------------------------------------------------------
 
   /** Write a {@code double} field, including tag, to the stream. */
@@ -202,6 +235,7 @@ public final class CodedOutputStream {
     writeTag(fieldNumber, WireFormat.WIRETYPE_END_GROUP);
   }
 
+
   /**
    * Write a group represented by an {@link UnknownFieldSet}.
    *
@@ -222,6 +256,7 @@ public final class CodedOutputStream {
     writeMessageNoTag(value);
   }
 
+
   /** Write a {@code bytes} field, including tag, to the stream. */
   public void writeBytes(final int fieldNumber, final ByteString value)
                          throws IOException {
@@ -229,6 +264,39 @@ public final class CodedOutputStream {
     writeBytesNoTag(value);
   }
 
+  /** Write a {@code bytes} field, including tag, to the stream. */
+  public void writeByteArray(final int fieldNumber, final byte[] value)
+                             throws IOException {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED);
+    writeByteArrayNoTag(value);
+  }
+
+  /** Write a {@code bytes} field, including tag, to the stream. */
+  public void writeByteArray(final int fieldNumber,
+                             final byte[] value,
+                             final int offset,
+                             final int length)
+                             throws IOException {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED);
+    writeByteArrayNoTag(value, offset, length);
+  }
+
+  /**
+   * Write a {@code bytes} field, including tag, to the stream.
+   * This method will write all content of the ByteBuffer regardless of the
+   * current position and limit (i.e., the number of bytes to be written is
+   * value.capacity(), not value.remaining()). Furthermore, this method doesn't
+   * alter the state of the passed-in ByteBuffer. Its position, limit, mark,
+   * etc. will remain unchanged. If you only want to write the remaining bytes
+   * of a ByteBuffer, you can call
+   * {@code writeByteBuffer(fieldNumber, byteBuffer.slice())}.
+   */
+  public void writeByteBuffer(final int fieldNumber, final ByteBuffer value)
+      throws IOException {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED);
+    writeByteBufferNoTag(value);
+  }
+
   /** Write a {@code uint32} field, including tag, to the stream. */
   public void writeUInt32(final int fieldNumber, final int value)
                           throws IOException {
@@ -362,6 +430,7 @@ public final class CodedOutputStream {
     value.writeTo(this);
   }
 
+
   /**
    * Write a group represented by an {@link UnknownFieldSet}.
    *
@@ -380,12 +449,41 @@ public final class CodedOutputStream {
     value.writeTo(this);
   }
 
+
   /** Write a {@code bytes} field to the stream. */
   public void writeBytesNoTag(final ByteString value) throws IOException {
     writeRawVarint32(value.size());
     writeRawBytes(value);
   }
 
+  /** Write a {@code bytes} field to the stream. */
+  public void writeByteArrayNoTag(final byte[] value) throws IOException {
+    writeRawVarint32(value.length);
+    writeRawBytes(value);
+  }
+
+  /** Write a {@code bytes} field to the stream. */
+  public void writeByteArrayNoTag(final byte[] value,
+                                  final int offset,
+                                  final int length) throws IOException {
+    writeRawVarint32(length);
+    writeRawBytes(value, offset, length);
+  }
+
+  /**
+   * Write a {@code bytes} field to the stream.  This method will write all
+   * content of the ByteBuffer regardless of the current position and limit
+   * (i.e., the number of bytes to be written is value.capacity(), not
+   * value.remaining()). Furthermore, this method doesn't alter the state of
+   * the passed-in ByteBuffer. Its position, limit, mark, etc. will remain
+   * unchanged. If you only want to write the remaining bytes of a ByteBuffer,
+   * you can call {@code writeByteBufferNoTag(byteBuffer.slice())}.
+   */
+  public void writeByteBufferNoTag(final ByteBuffer value) throws IOException {
+    writeRawVarint32(value.capacity());
+    writeRawBytes(value);
+  }
+
   /** Write a {@code uint32} field to the stream. */
   public void writeUInt32NoTag(final int value) throws IOException {
     writeRawVarint32(value);
@@ -540,11 +638,29 @@ public final class CodedOutputStream {
   }
 
   /**
+   * Compute the number of bytes that would be needed to encode a
+   * {@code bytes} field, including tag.
+   */
+  public static int computeByteArraySize(final int fieldNumber,
+                                         final byte[] value) {
+    return computeTagSize(fieldNumber) + computeByteArraySizeNoTag(value);
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode a
+   * {@code bytes} field, including tag.
+   */
+  public static int computeByteBufferSize(final int fieldNumber,
+                                         final ByteBuffer value) {
+    return computeTagSize(fieldNumber) + computeByteBufferSizeNoTag(value);
+  }
+
+  /**
    * Compute the number of bytes that would be needed to encode an
    * embedded message in lazy field, including tag.
    */
   public static int computeLazyFieldSize(final int fieldNumber,
-                                         final LazyField value) {
+                                         final LazyFieldLite value) {
     return computeTagSize(fieldNumber) + computeLazyFieldSizeNoTag(value);
   }
 
@@ -629,7 +745,7 @@ public final class CodedOutputStream {
    * historical reasons, the wire format differs from normal fields.
    */
   public static int computeLazyFieldMessageSetExtensionSize(
-      final int fieldNumber, final LazyField value) {
+      final int fieldNumber, final LazyFieldLite value) {
     return computeTagSize(WireFormat.MESSAGE_SET_ITEM) * 2 +
            computeUInt32Size(WireFormat.MESSAGE_SET_TYPE_ID, fieldNumber) +
            computeLazyFieldSize(WireFormat.MESSAGE_SET_MESSAGE, value);
@@ -754,7 +870,7 @@ public final class CodedOutputStream {
    * Compute the number of bytes that would be needed to encode an embedded
    * message stored in lazy field.
    */
-  public static int computeLazyFieldSizeNoTag(final LazyField value) {
+  public static int computeLazyFieldSizeNoTag(final LazyFieldLite value) {
     final int size = value.getSerializedSize();
     return computeRawVarint32Size(size) + size;
   }
@@ -770,6 +886,22 @@ public final class CodedOutputStream {
 
   /**
    * Compute the number of bytes that would be needed to encode a
+   * {@code bytes} field.
+   */
+  public static int computeByteArraySizeNoTag(final byte[] value) {
+    return computeRawVarint32Size(value.length) + value.length;
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode a
+   * {@code bytes} field.
+   */
+  public static int computeByteBufferSizeNoTag(final ByteBuffer value) {
+    return computeRawVarint32Size(value.capacity()) + value.capacity();
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode a
    * {@code uint32} field.
    */
   public static int computeUInt32SizeNoTag(final int value) {
@@ -886,6 +1018,15 @@ public final class CodedOutputStream {
     }
   }
 
+  /**
+   * Get the total number of bytes successfully written to this stream.  The
+   * returned value is not guaranteed to be accurate if exceptions have been
+   * found in the middle of writing.
+   */
+  public int getTotalBytesWritten() {
+    return totalBytesWritten;
+  }
+
   /** Write a single byte. */
   public void writeRawByte(final byte value) throws IOException {
     if (position == limit) {
@@ -893,6 +1034,7 @@ public final class CodedOutputStream {
     }
 
     buffer[position++] = value;
+    ++totalBytesWritten;
   }
 
   /** Write a single byte, represented by an integer value. */
@@ -910,6 +1052,61 @@ public final class CodedOutputStream {
     writeRawBytes(value, 0, value.length);
   }
 
+  /**
+   * Write a ByteBuffer. This method will write all content of the ByteBuffer
+   * regardless of the current position and limit (i.e., the number of bytes
+   * to be written is value.capacity(), not value.remaining()). Furthermore,
+   * this method doesn't alter the state of the passed-in ByteBuffer. Its
+   * position, limit, mark, etc. will remain unchanged. If you only want to
+   * write the remaining bytes of a ByteBuffer, you can call
+   * {@code writeRawBytes(byteBuffer.slice())}.
+   */
+  public void writeRawBytes(final ByteBuffer value) throws IOException {
+    if (value.hasArray()) {
+      writeRawBytes(value.array(), value.arrayOffset(), value.capacity());
+    } else {
+      ByteBuffer duplicated = value.duplicate();
+      duplicated.clear();
+      writeRawBytesInternal(duplicated);
+    }
+  }
+
+  /** Write a ByteBuffer that isn't backed by an array. */
+  private void writeRawBytesInternal(final ByteBuffer value)
+      throws IOException {
+    int length = value.remaining();
+    if (limit - position >= length) {
+      // We have room in the current buffer.
+      value.get(buffer, position, length);
+      position += length;
+      totalBytesWritten += length;
+    } else {
+      // Write extends past current buffer.  Fill the rest of this buffer and
+      // flush.
+      final int bytesWritten = limit - position;
+      value.get(buffer, position, bytesWritten);
+      length -= bytesWritten;
+      position = limit;
+      totalBytesWritten += bytesWritten;
+      refreshBuffer();
+
+      // Now deal with the rest.
+      // Since we have an output stream, this is our buffer
+      // and buffer offset == 0
+      while (length > limit) {
+        // Copy data into the buffer before writing it to OutputStream.
+        // TODO(xiaofeng): Introduce ZeroCopyOutputStream to avoid this copy.
+        value.get(buffer, 0, limit);
+        output.write(buffer, 0, limit);
+        length -= limit;
+        totalBytesWritten += limit;
+      }
+      value.get(buffer, 0, length);
+      position = length;
+      totalBytesWritten += length;
+    }
+  }
+
   /** Write part of an array of bytes. */
   public void writeRawBytes(final byte[] value, int offset, int length)
                             throws IOException {
@@ -917,6 +1114,7 @@ public final class CodedOutputStream {
       // We have room in the current buffer.
       System.arraycopy(value, offset, buffer, position, length);
       position += length;
+      totalBytesWritten += length;
     } else {
       // Write extends past current buffer.  Fill the rest of this buffer and
       // flush.
@@ -925,6 +1123,7 @@ public final class CodedOutputStream {
       offset += bytesWritten;
       length -= bytesWritten;
       position = limit;
+      totalBytesWritten += bytesWritten;
       refreshBuffer();
 
       // Now deal with the rest.
@@ -938,6 +1137,7 @@ public final class CodedOutputStream {
         // Write is very big.  Let's do it all at once.
         output.write(value, offset, length);
       }
+      totalBytesWritten += length;
     }
   }
 
@@ -948,6 +1148,7 @@ public final class CodedOutputStream {
       // We have room in the current buffer.
       value.copyTo(buffer, offset, position, length);
       position += length;
+      totalBytesWritten += length;
     } else {
       // Write extends past current buffer.  Fill the rest of this buffer and
       // flush.
@@ -956,6 +1157,7 @@ public final class CodedOutputStream {
       offset += bytesWritten;
       length -= bytesWritten;
       position = limit;
+      totalBytesWritten += bytesWritten;
       refreshBuffer();
 
       // Now deal with the rest.
@@ -966,25 +1168,9 @@ public final class CodedOutputStream {
         value.copyTo(buffer, offset, 0, length);
         position = length;
       } else {
-        // Write is very big, but we can't do it all at once without allocating
-        // an a copy of the byte array since ByteString does not give us access
-        // to the underlying bytes. Use the InputStream interface on the
-        // ByteString and our buffer to copy between the two.
-        InputStream inputStreamFrom = value.newInput();
-        if (offset != inputStreamFrom.skip(offset)) {
-          throw new IllegalStateException("Skip failed? Should never happen.");
-        }
-        // Use the buffer as the temporary buffer to avoid allocating memory.
-        while (length > 0) {
-          int bytesToRead = Math.min(length, limit);
-          int bytesRead = inputStreamFrom.read(buffer, 0, bytesToRead);
-          if (bytesRead != bytesToRead) {
-            throw new IllegalStateException("Read failed? Should never happen");
-          }
-          output.write(buffer, 0, bytesRead);
-          length -= bytesRead;
-        }
+        value.writeTo(output, offset, length);
       }
+      totalBytesWritten += length;
     }
   }