third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/java/core/src/main/java/com/google/protobuf/Internal.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 42 matching lines @@
  * @author kenton@google.com (Kenton Varda)
  */
 public final class Internal {
 
   private Internal() {}
 
   static final Charset UTF_8 = Charset.forName("UTF-8");
   static final Charset ISO_8859_1 = Charset.forName("ISO-8859-1");
 
   /**
+   * Throws an appropriate {@link NullPointerException} if the given objects is {@code null}.
+   */
+  static <T> T checkNotNull(T obj, String message) {
+    if (obj == null) {
+      throw new NullPointerException(message);
+    }
+    return obj;
+  }
+
+  /**
    * Helper called by generated code to construct default values for string
    * fields.
    * <p>
    * The protocol compiler does not actually contain a UTF-8 decoder -- it
    * just pushes UTF-8-encoded text around without touching it.  The one place
    * where this presents a problem is when generating Java string literals.
    * Unicode characters in the string literal would normally need to be encoded
    * using a Unicode escape sequence, which would require decoding them.
    * To get around this, protoc instead embeds the UTF-8 bytes into the
    * generated code and leaves it to the runtime library to decode them.
@@ skipping 531 matching lines @@
    * possible. Does not support null elements.
    */
   public static interface IntList extends ProtobufList<Integer> {
 
     /**
      * Like {@link #get(int)} but more efficient in that it doesn't box the returned value.
      */
     int getInt(int index);
 
     /**
-     * Like {@link #add(Integer)} but more efficient in that it doesn't box the element.
+     * Like {@link #add(Object)} but more efficient in that it doesn't box the element.
      */
     void addInt(int element);
 
     /**
-     * Like {@link #set(int, Integer)} but more efficient in that it doesn't box the element.
+     * Like {@link #set(int, Object)} but more efficient in that it doesn't box the element.
      */
     int setInt(int index, int element);
 
     /**
      * Returns a mutable clone of this list with the specified capacity.
      */
     @Override
     IntList mutableCopyWithCapacity(int capacity);
   }
 
   /**
    * A {@link java.util.List} implementation that avoids boxing the elements into Booleans if
    * possible. Does not support null elements.
    */
   public static interface BooleanList extends ProtobufList<Boolean> {
 
     /**
      * Like {@link #get(int)} but more efficient in that it doesn't box the returned value.
      */
     boolean getBoolean(int index);
 
     /**
-     * Like {@link #add(Boolean)} but more efficient in that it doesn't box the element.
+     * Like {@link #add(Object)} but more efficient in that it doesn't box the element.
      */
     void addBoolean(boolean element);
 
     /**
-     * Like {@link #set(int, Boolean)} but more efficient in that it doesn't box the element.
+     * Like {@link #set(int, Object)} but more efficient in that it doesn't box the element.
      */
     boolean setBoolean(int index, boolean element);
 
     /**
      * Returns a mutable clone of this list with the specified capacity.
      */
     @Override
     BooleanList mutableCopyWithCapacity(int capacity);
   }
 
   /**
    * A {@link java.util.List} implementation that avoids boxing the elements into Longs if
    * possible. Does not support null elements.
    */
   public static interface LongList extends ProtobufList<Long> {
 
     /**
      * Like {@link #get(int)} but more efficient in that it doesn't box the returned value.
      */
     long getLong(int index);
 
     /**
-     * Like {@link #add(Long)} but more efficient in that it doesn't box the element.
+     * Like {@link #add(Object)} but more efficient in that it doesn't box the element.
      */
     void addLong(long element);
 
     /**
-     * Like {@link #set(int, Long)} but more efficient in that it doesn't box the element.
+     * Like {@link #set(int, Object)} but more efficient in that it doesn't box the element.
      */
     long setLong(int index, long element);
 
     /**
      * Returns a mutable clone of this list with the specified capacity.
      */
     @Override
     LongList mutableCopyWithCapacity(int capacity);
   }
 
   /**
    * A {@link java.util.List} implementation that avoids boxing the elements into Doubles if
    * possible. Does not support null elements.
    */
   public static interface DoubleList extends ProtobufList<Double> {
 
     /**
      * Like {@link #get(int)} but more efficient in that it doesn't box the returned value.
      */
     double getDouble(int index);
 
     /**
-     * Like {@link #add(Double)} but more efficient in that it doesn't box the element.
+     * Like {@link #add(Object)} but more efficient in that it doesn't box the element.
      */
     void addDouble(double element);
 
     /**
-     * Like {@link #set(int, Double)} but more efficient in that it doesn't box the element.
+     * Like {@link #set(int, Object)} but more efficient in that it doesn't box the element.
      */
     double setDouble(int index, double element);
 
     /**
      * Returns a mutable clone of this list with the specified capacity.
      */
     @Override
     DoubleList mutableCopyWithCapacity(int capacity);
   }
 
   /**
    * A {@link java.util.List} implementation that avoids boxing the elements into Floats if
    * possible. Does not support null elements.
    */
   public static interface FloatList extends ProtobufList<Float> {
 
     /**
      * Like {@link #get(int)} but more efficient in that it doesn't box the returned value.
      */
     float getFloat(int index);
 
     /**
-     * Like {@link #add(Float)} but more efficient in that it doesn't box the element.
+     * Like {@link #add(Object)} but more efficient in that it doesn't box the element.
      */
     void addFloat(float element);
 
     /**
-     * Like {@link #set(int, Float)} but more efficient in that it doesn't box the element.
+     * Like {@link #set(int, Object)} but more efficient in that it doesn't box the element.
      */
     float setFloat(int index, float element);
 
     /**
      * Returns a mutable clone of this list with the specified capacity.
      */
     @Override
     FloatList mutableCopyWithCapacity(int capacity);
   }
 }