third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/java/core/src/main/java/com/google/protobuf/ByteString.java

 // 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.
@@ skipping 33 matching lines @@
 import java.nio.charset.UnsupportedCharsetException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 import java.util.NoSuchElementException;
 
 /**
- * Immutable sequence of bytes.  Substring is supported by sharing the reference
- * to the immutable underlying bytes, as with {@link String}.  Concatenation is
- * likewise supported without copying (long strings) by building a tree of
- * pieces in {@link RopeByteString}.
- * <p>
- * Like {@link String}, the contents of a {@link ByteString} can never be
- * observed to change, not even in the presence of a data race or incorrect
- * API usage in the client code.
+ * Immutable sequence of bytes. Substring is supported by sharing the reference to the immutable
+ * underlying bytes. Concatenation is likewise supported without copying (long strings) by building
+ * a tree of pieces in {@link RopeByteString}.
+ *
+ * <p>Like {@link String}, the contents of a {@link ByteString} can never be observed to change, not
+ * even in the presence of a data race or incorrect API usage in the client code.
  *
  * @author crazybob@google.com Bob Lee
  * @author kenton@google.com Kenton Varda
  * @author carlanton@google.com Carl Haverl
  * @author martinrb@google.com Martin Buchholz
  */
 public abstract class ByteString implements Iterable<Byte>, Serializable {
 
   /**
    * When two strings to be concatenated have a combined length shorter than
    * this, we just copy their bytes on {@link #concat(ByteString)}.
    * The trade-off is copy size versus the overhead of creating tree nodes
    * in {@link RopeByteString}.
    */
   static final int CONCATENATE_BY_COPY_SIZE = 128;
 
   /**
    * When copying an InputStream into a ByteString with .readFrom(),
    * the chunks in the underlying rope start at 256 bytes, but double
    * each iteration up to 8192 bytes.
    */
   static final int MIN_READ_FROM_CHUNK_SIZE = 0x100;  // 256b
   static final int MAX_READ_FROM_CHUNK_SIZE = 0x2000;  // 8k
 
   /**
    * Empty {@code ByteString}.
    */
   public static final ByteString EMPTY = new LiteralByteString(Internal.EMPTY_BYTE_ARRAY);
-  
-  /** 
+
+  /**
    * An interface to efficiently copy {@code byte[]}.
-   * 
-   * <p>One of the noticable costs of copying a byte[] into a new array using 
-   * {@code System.arraycopy} is nullification of a new buffer before the copy. It has been shown 
+   *
+   * <p>One of the noticeable costs of copying a byte[] into a new array using
+   * {@code System.arraycopy} is nullification of a new buffer before the copy. It has been shown
    * the Hotspot VM is capable to intrisicfy {@code Arrays.copyOfRange} operation to avoid this
    * expensive nullification and provide substantial performance gain. Unfortunately this does not
    * hold on Android runtimes and could make the copy slightly slower due to additional code in
    * the {@code Arrays.copyOfRange}. Thus we provide two different implementation for array copier
-   * for Hotspot and Android runtimes. 
+   * for Hotspot and Android runtimes.
    */
   private interface ByteArrayCopier {
     /**
      * Copies the specified range of the specified array into a new array
      */
     byte[] copyFrom(byte[] bytes, int offset, int size);
   }
-  
+
   /** Implementation of {@code ByteArrayCopier} which uses {@link System#arraycopy}. */
   private static final class SystemByteArrayCopier implements ByteArrayCopier {
     @Override
     public byte[] copyFrom(byte[] bytes, int offset, int size) {
       byte[] copy = new byte[size];
       System.arraycopy(bytes, offset, copy, 0, size);
       return copy;
     }
   }
-  
+
   /** Implementation of {@code ByteArrayCopier} which uses {@link Arrays#copyOfRange}. */
   private static final class ArraysByteArrayCopier implements ByteArrayCopier {
     @Override
     public byte[] copyFrom(byte[] bytes, int offset, int size) {
       return Arrays.copyOfRange(bytes, offset, offset + size);
     }
   }
-  
+
   private static final ByteArrayCopier byteArrayCopier;
   static {
     boolean isAndroid = true;
     try {
       Class.forName("android.content.Context");
     } catch (ClassNotFoundException e) {
       isAndroid = false;
     }
-    
+
     byteArrayCopier = isAndroid ? new SystemByteArrayCopier() : new ArraysByteArrayCopier();
   }
 
   /**
    * Cached hash value. Intentionally accessed via a data race, which
    * is safe because of the Java Memory Model's "no out-of-thin-air values"
    * guarantees for ints. A value of 0 implies that the hash has not been set.
    */
   private int hash = 0;
 
@@ skipping 156 matching lines @@
 
   /**
    * Copies the given bytes into a {@code ByteString}.
    *
    * @param bytes to copy
    * @return new {@code ByteString}
    */
   public static ByteString copyFrom(byte[] bytes) {
     return copyFrom(bytes, 0, bytes.length);
   }
-  
+
+  /**
+   * Wraps the given bytes into a {@code ByteString}. Intended for internal only usage.
+   */
+  static ByteString wrap(ByteBuffer buffer) {
+    if (buffer.hasArray()) {
+      final int offset = buffer.arrayOffset();
+      return ByteString.wrap(buffer.array(), offset + buffer.position(), buffer.remaining());
+    } else {
+      return new NioByteString(buffer);
+    }
+  }
+
   /**
    * Wraps the given bytes into a {@code ByteString}. Intended for internal only
    * usage to force a classload of ByteString before LiteralByteString.
    */
   static ByteString wrap(byte[] bytes) {
     // TODO(dweis): Return EMPTY when bytes are empty to reduce allocations?
     return new LiteralByteString(bytes);
   }
 
   /**
@@ skipping 72 matching lines @@
 
   /**
    * Completely reads the given stream's bytes into a
    * {@code ByteString}, blocking if necessary until all bytes are
    * read through to the end of the stream.
    *
    * <b>Performance notes:</b> The returned {@code ByteString} is an
    * immutable tree of byte arrays ("chunks") of the stream data.  The
    * first chunk is small, with subsequent chunks each being double
    * the size, up to 8K.
-   * 
+   *
    * <p>Each byte read from the input stream will be copied twice to ensure
    * that the resulting ByteString is truly immutable.
    *
    * @param streamToDrain The source stream, which is read completely
    *     but not closed.
    * @return A new {@code ByteString} which is made up of chunks of
    *     various sizes, depending on the behavior of the underlying
    *     stream.
    * @throws IOException IOException is thrown if there is a problem
    *     reading the underlying stream.
@@ skipping 130 matching lines @@
       return EMPTY;
     }
 
     return balancedConcat(byteStrings.iterator(), size);
   }
 
   // Internal function used by copyFrom(Iterable<ByteString>).
   // Create a balanced concatenation of the next "length" elements from the
   // iterable.
   private static ByteString balancedConcat(Iterator<ByteString> iterator, int length) {
-    assert length >= 1;
+    if (length < 1) {
+      throw new IllegalArgumentException(String.format("length (%s) must be >= 1", length));
+    }
     ByteString result;
     if (length == 1) {
       result = iterator.next();
     } else {
       int halfLength = length >>> 1;
       ByteString left = balancedConcat(iterator, halfLength);
       ByteString right = balancedConcat(iterator, length - halfLength);
       result = left.concat(right);
     }
     return result;
@@ skipping 105 matching lines @@
    * <p>This method may expose internal backing buffers of the {@link ByteString} to the {@link
    * ByteOutput} in order to avoid additional copying overhead. It would be possible for a malicious
    * {@link ByteOutput} to corrupt the {@link ByteString}. Use with caution!
    *
    * @param  byteOutput  the output target to receive the bytes
    * @throws IOException  if an I/O error occurs
    * @see UnsafeByteOperations#unsafeWriteTo(ByteString, ByteOutput)
    */
   abstract void writeTo(ByteOutput byteOutput) throws IOException;
 
+
   /**
    * Constructs a read-only {@code java.nio.ByteBuffer} whose content
    * is equal to the contents of this byte string.
    * The result uses the same backing array as the byte string, if possible.
    *
    * @return wrapped bytes
    */
   public abstract ByteBuffer asReadOnlyByteBuffer();
 
   /**
@@ skipping 121 matching lines @@
     @Override
     protected final int getTreeDepth() {
       return 0;
     }
 
     @Override
     protected final boolean isBalanced() {
       return true;
     }
 
+
     /**
      * Check equality of the substring of given length of this object starting at
      * zero with another {@code ByteString} substring starting at offset.
      *
      * @param other  what to compare a substring in
      * @param offset offset into other
      * @param length number of bytes to compare
      * @return true for equality of substrings, else false.
      */
     abstract boolean equalsRange(ByteString other, int offset, int length);
@@ skipping 386 matching lines @@
       throw new IndexOutOfBoundsException("End index: " + endIndex + " >= " + size);
     }
     return length;
   }
 
   @Override
   public final String toString() {
     return String.format("<ByteString@%s size=%d>",
         Integer.toHexString(System.identityHashCode(this)), size());
   }
-  
+
   /**
    * This class implements a {@link com.google.protobuf.ByteString} backed by a
    * single array of bytes, contiguous in memory. It supports substring by
    * pointing to only a sub-range of the underlying byte array, meaning that a
    * substring will reference the full byte-array of the string it's made from,
    * exactly as with {@link String}.
    *
    * @author carlanton@google.com (Carl Haverl)
    */
   // Keep this class private to avoid deadlocks in classloading across threads as ByteString's
@@ skipping 203 matching lines @@
 
     /**
      * Offset into {@code bytes[]} to use, non-zero for substrings.
      *
      * @return always 0 for this class
      */
     protected int getOffsetIntoBytes() {
       return 0;
     }
   }
-  
+
   /**
    * This class is used to represent the substring of a {@link ByteString} over a
    * single byte array. In terms of the public API of {@link ByteString}, you end
    * up here by calling {@link ByteString#copyFrom(byte[])} followed by {@link
    * ByteString#substring(int, int)}.
    *
    * <p>This class contains most of the overhead involved in creating a substring
    * from a {@link LiteralByteString}.  The overhead involves some range-checking
    * and two extra fields.
    *
@@ skipping 71 matching lines @@
     Object writeReplace() {
       return ByteString.wrap(toByteArray());
     }
 
     private void readObject(@SuppressWarnings("unused") ObjectInputStream in) throws IOException {
       throw new InvalidObjectException(
           "BoundedByteStream instances are not to be serialized directly");
     }
   }
 }