Merge remote-tracking branch 'origin/make-lite-private' into make-lite-private

Author: blakeli0

protobuf-api/src/main/java/com/google/protobuf/Internal.java

@@ -14,7 +14,9 @@
 import java.util.AbstractList;
 import java.util.AbstractMap;
 import java.util.AbstractSet;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
@@ -126,6 +128,67 @@ public static ByteBuffer copyByteBuffer(ByteBuffer source) {
     return result;
   }
 
+  /**
+   * 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.
+   */
+  public 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: 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);
+      }
+    }
+  }
+
+  // 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);
+    }
+  }
+
   /**
    * Helper called by generated code to determine if a byte array is a valid UTF-8 encoded string
    * such that the original bytes can be converted to a String object and then back to a byte array