AuroraMiddleware/protobuf
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity

Merge pull request #765 from xfxyjwf/javadoc

Browse Source 
Fix javadoc errors.
This commit is contained in:
Feng Xiao 2015-08-27 14:34:19 -07:00
commit 26f0c678f6
4 changed files with 25 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
java/src/main/java/com/google/protobuf/ByteString.java
View File

@ -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>
* Table 3-6. <em>UTF-8 Bit Distribution</em>,</br>
* <p>See the Unicode Standard,<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

29
java/src/main/java/com/google/protobuf/Internal.java
View File

@ -156,8 +156,8 @@ public class Internal {
* but currently (2011) still accepts 3-byte surrogate character
* byte sequences.
*
* <p>See the Unicode Standard,</br>
* Table 3-6. <em>UTF-8 Bit Distribution</em>,</br>
* <p>See the Unicode Standard,<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);
}

2
java/src/main/java/com/google/protobuf/RopeByteString.java
View File

@ -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

12
java/src/main/java/com/google/protobuf/TextFormat.java
View File

@ -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>"foo: 1 foo: 2"
* <ul>"baz: 1 qux: 2"
* <ul>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>
* <ul>
* <li>"foo: 1 foo: 2"
* <li>"baz: 1 qux: 2"
* <li>merging "foo: 2" into a proto in which foo is already set, or
* <li>merging "qux: 2" into a proto in which baz is already set.
* </ul>
*/
public enum SingularOverwritePolicy {
/** The last value is retained. */