Merge pull request #765 from xfxyjwf/javadoc

Fix javadoc errors.

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

@@ -94,7 +94,7 @@ public abstract class ByteString implements Iterable<Byte>, Serializable {
    *
    * @param index index of byte
    * @return the value
-   * @throws ArrayIndexOutOfBoundsException {@code index} is < 0 or >= size
+   * @throws ArrayIndexOutOfBoundsException {@code index < 0 or index >= size}
    */
   public abstract byte byteAt(int index);
 
@@ -679,8 +679,8 @@ public abstract class ByteString implements Iterable<Byte>, Serializable {
    * sequences, but (as of 2011) still accepts 3-byte surrogate
    * character byte sequences.
    *
-   * <p>See the Unicode Standard,</br>
+   * <p>See the Unicode Standard,<br>
-   * Table 3-6. <em>UTF-8 Bit Distribution</em>,</br>
+   * Table 3-6. <em>UTF-8 Bit Distribution</em>,<br>
    * Table 3-7. <em>Well Formed UTF-8 Byte Sequences</em>.
    *
    * @return whether the bytes in this {@code ByteString} are a

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

@@ -156,8 +156,8 @@ public class Internal {
    * but currently (2011) still accepts 3-byte surrogate character
    * byte sequences.
    *
-   * <p>See the Unicode Standard,</br>
+   * <p>See the Unicode Standard,<br>
-   * Table 3-6. <em>UTF-8 Bit Distribution</em>,</br>
+   * Table 3-6. <em>UTF-8 Bit Distribution</em>,<br>
    * Table 3-7. <em>Well Formed UTF-8 Byte Sequences</em>.
    *
    * <p>As of 2011-02, this method simply returns the result of {@link
@@ -387,7 +387,7 @@ public class Internal {
 
 
   /**
-   * Provides an immutable view of List<T> around a List<F>.
+   * Provides an immutable view of {@code List<T>} around a {@code List<F>}.
    *
    * Protobuf internal. Used in protobuf generated code only.
    */
@@ -419,7 +419,8 @@ public class Internal {
   }
 
   /**
-   * Wrap around a Map<K, RealValue> and provide a Map<K, V> interface.
+   * Wrap around a {@code Map<K, RealValue>} and provide a {@code Map<K, V>}
+   * interface.
    */
   public static class MapAdapter<K, V, RealValue> extends AbstractMap<K, V> {
     /**
@@ -576,12 +577,12 @@ public class Internal {
     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);
   }
@@ -598,12 +599,12 @@ public class Internal {
     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);
   }
@@ -620,12 +621,12 @@ public class Internal {
     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);
   }
@@ -642,12 +643,12 @@ public class Internal {
     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);
   }
@@ -664,12 +665,12 @@ public class Internal {
     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);
   }

java/src/main/java/com/google/protobuf/RopeByteString.java

@@ -56,7 +56,7 @@ import java.util.Stack;
  * michael plass
  *
  * <p>The algorithms described in the paper have been implemented for character
- * strings in {@link com.google.common.string.Rope} and in the c++ class {@code
+ * strings in {@code com.google.common.string.Rope} and in the c++ class {@code
  * cord.cc}.
  *
  * <p>Fundamentally the Rope algorithm represents the collection of pieces as a

java/src/main/java/com/google/protobuf/TextFormat.java

@@ -1175,12 +1175,12 @@ public final class TextFormat {
      * Determines if repeated values for non-repeated fields and
      * oneofs are permitted. For example, given required/optional field "foo"
      * and a oneof containing "baz" and "qux":
-     * <li>
+     * <ul>
-     * <ul>"foo: 1 foo: 2"
+     * <li>"foo: 1 foo: 2"
-     * <ul>"baz: 1 qux: 2"
+     * <li>"baz: 1 qux: 2"
-     * <ul>merging "foo: 2" into a proto in which foo is already set, or
+     * <li>merging "foo: 2" into a proto in which foo is already set, or
-     * <ul>merging "qux: 2" into a proto in which baz is already set.
+     * <li>merging "qux: 2" into a proto in which baz is already set.
-     * </li>
+     * </ul>
      */
     public enum SingularOverwritePolicy {
       /** The last value is retained. */