This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git
commit 514d39dc6bb581c947dc85b27d3d40e582786487
Author: Gary D. Gregory <garydgreg...@gmail.com>
AuthorDate: Sat Jun 14 07:14:14 2025 -0400
Javadoc
---
.../apache/commons/lang3/tuple/ImmutablePair.java | 4 +-
.../commons/lang3/tuple/ImmutableTriple.java | 73 +++++++++++-----------
.../apache/commons/lang3/tuple/MutablePair.java | 56 ++++++++---------
.../apache/commons/lang3/tuple/MutableTriple.java | 64 +++++++++----------
.../java/org/apache/commons/lang3/tuple/Pair.java | 62 +++++++++---------
.../org/apache/commons/lang3/tuple/Triple.java | 68 ++++++++++----------
6 files changed, 164 insertions(+), 163 deletions(-)
diff --git a/src/main/java/org/apache/commons/lang3/tuple/ImmutablePair.java
b/src/main/java/org/apache/commons/lang3/tuple/ImmutablePair.java
index 36a7a3ff1..f7fe6fc93 100644
--- a/src/main/java/org/apache/commons/lang3/tuple/ImmutablePair.java
+++ b/src/main/java/org/apache/commons/lang3/tuple/ImmutablePair.java
@@ -40,7 +40,7 @@ public class ImmutablePair<L, R> extends Pair<L, R> {
* Consider using {@link #emptyArray()} to avoid generics warnings.
* </p>
*
- * @since 3.10.
+ * @since 3.10
*/
public static final ImmutablePair<?, ?>[] EMPTY_ARRAY = {};
@@ -60,7 +60,7 @@ public class ImmutablePair<L, R> extends Pair<L, R> {
* @param <L> the left element type
* @param <R> the right element type
* @return the empty array singleton that can be assigned without compiler
warning.
- * @since 3.10.
+ * @since 3.10
*/
@SuppressWarnings("unchecked")
public static <L, R> ImmutablePair<L, R>[] emptyArray() {
diff --git a/src/main/java/org/apache/commons/lang3/tuple/ImmutableTriple.java
b/src/main/java/org/apache/commons/lang3/tuple/ImmutableTriple.java
index f1c5e98d8..9daa711df 100644
--- a/src/main/java/org/apache/commons/lang3/tuple/ImmutableTriple.java
+++ b/src/main/java/org/apache/commons/lang3/tuple/ImmutableTriple.java
@@ -25,11 +25,11 @@
* that may be stored. If mutable objects are stored in the triple, then the
triple
* itself effectively becomes mutable.</p>
*
- * <p>#ThreadSafe# if all three objects are thread-safe</p>
+ * <p>#ThreadSafe# if all three objects are thread-safe.</p>
*
- * @param <L> the left element type
- * @param <M> the middle element type
- * @param <R> the right element type
+ * @param <L> the left element type.
+ * @param <M> the middle element type.
+ * @param <R> the right element type.
* @since 3.2
*/
public class ImmutableTriple<L, M, R> extends Triple<L, M, R> {
@@ -40,7 +40,7 @@ public class ImmutableTriple<L, M, R> extends Triple<L, M, R>
{
* Consider using {@link #emptyArray()} to avoid generics warnings.
* </p>
*
- * @since 3.10.
+ * @since 3.10
*/
public static final ImmutableTriple<?, ?, ?>[] EMPTY_ARRAY = {};
@@ -51,17 +51,17 @@ public class ImmutableTriple<L, M, R> extends Triple<L, M,
R> {
@SuppressWarnings("rawtypes")
private static final ImmutableTriple NULL = new ImmutableTriple<>(null,
null, null);
- /** Serialization version */
+ /** Serialization version. */
private static final long serialVersionUID = 1L;
/**
- * Returns the empty array singleton that can be assigned without compiler
warning.
+ * Gets the empty array singleton that can be assigned without compiler
warning.
*
- * @param <L> the left element type
- * @param <M> the middle element type
- * @param <R> the right element type
+ * @param <L> the left element type.
+ * @param <M> the middle element type.
+ * @param <R> the right element type.
* @return the empty array singleton that can be assigned without compiler
warning.
- * @since 3.10.
+ * @since 3.10
*/
@SuppressWarnings("unchecked")
public static <L, M, R> ImmutableTriple<L, M, R>[] emptyArray() {
@@ -69,7 +69,7 @@ public static <L, M, R> ImmutableTriple<L, M, R>[]
emptyArray() {
}
/**
- * Returns an immutable triple of nulls.
+ * Gets the immutable triple of nulls singleton.
*
* @param <L> the left element of this triple. Value is {@code null}.
* @param <M> the middle element of this triple. Value is {@code null}.
@@ -83,57 +83,58 @@ public static <L, M, R> ImmutableTriple<L, M, R>
nullTriple() {
}
/**
- * Obtains an immutable triple of three objects inferring the generic
types.
+ * Creates an immutable triple of three objects inferring the generic
types.
*
* <p>This factory allows the triple to be created using inference to
* obtain the generic types.</p>
*
- * @param <L> the left element type
- * @param <M> the middle element type
- * @param <R> the right element type
- * @param left the left element, may be null
- * @param middle the middle element, may be null
- * @param right the right element, may be null
- * @return a triple formed from the three parameters, not null
+ * @param <L> the left element type.
+ * @param <M> the middle element type.
+ * @param <R> the right element type.
+ * @param left the left element, may be null.
+ * @param middle the middle element, may be null.
+ * @param right the right element, may be null.
+ * @return a triple formed from the three parameters, not null.
*/
public static <L, M, R> ImmutableTriple<L, M, R> of(final L left, final M
middle, final R right) {
return left != null | middle != null || right != null ? new
ImmutableTriple<>(left, middle, right) : nullTriple();
}
/**
- * Obtains an immutable triple of three non-null objects inferring the
generic types.
+ * Creates an immutable triple of three non-null objects inferring the
generic types.
*
* <p>This factory allows the triple to be created using inference to
* obtain the generic types.</p>
*
- * @param <L> the left element type
- * @param <M> the middle element type
- * @param <R> the right element type
- * @param left the left element, may not be null
- * @param middle the middle element, may not be null
- * @param right the right element, may not be null
- * @return a triple formed from the three parameters, not null
- * @throws NullPointerException if any input is null
+ * @param <L> the left element type.
+ * @param <M> the middle element type.
+ * @param <R> the right element type.
+ * @param left the left element, may not be null.
+ * @param middle the middle element, may not be null.
+ * @param right the right element, may not be null.
+ * @return a triple formed from the three parameters, not null.
+ * @throws NullPointerException if any input is null.
* @since 3.13.0
*/
public static <L, M, R> ImmutableTriple<L, M, R> ofNonNull(final L left,
final M middle, final R right) {
return of(Objects.requireNonNull(left, "left"),
Objects.requireNonNull(middle, "middle"), Objects.requireNonNull(right,
"right"));
}
- /** Left object */
+ /** Left object. */
+
public final L left;
- /** Middle object */
+ /** Middle object. */
public final M middle;
- /** Right object */
+ /** Right object. */
public final R right;
/**
- * Create a new triple instance.
+ * Constructs a new triple instance.
*
- * @param left the left value, may be null
- * @param middle the middle value, may be null
- * @param right the right value, may be null
+ * @param left the left value, may be null.
+ * @param middle the middle value, may be null.
+ * @param right the right value, may be null.
*/
public ImmutableTriple(final L left, final M middle, final R right) {
this.left = left;
diff --git a/src/main/java/org/apache/commons/lang3/tuple/MutablePair.java
b/src/main/java/org/apache/commons/lang3/tuple/MutablePair.java
index 7a7d588d0..1940c7a85 100644
--- a/src/main/java/org/apache/commons/lang3/tuple/MutablePair.java
+++ b/src/main/java/org/apache/commons/lang3/tuple/MutablePair.java
@@ -24,8 +24,8 @@
*
* <p>Not #ThreadSafe#</p>
*
- * @param <L> the left element type
- * @param <R> the right element type
+ * @param <L> the left element type.
+ * @param <R> the right element type.
* @since 3.0
*/
public class MutablePair<L, R> extends Pair<L, R> {
@@ -36,7 +36,7 @@ public class MutablePair<L, R> extends Pair<L, R> {
* Consider using {@link #emptyArray()} to avoid generics warnings.
* </p>
*
- * @since 3.10.
+ * @since 3.10
*/
public static final MutablePair<?, ?>[] EMPTY_ARRAY = {};
@@ -46,10 +46,10 @@ public class MutablePair<L, R> extends Pair<L, R> {
/**
* Returns the empty array singleton that can be assigned without compiler
warning.
*
- * @param <L> the left element type
- * @param <R> the right element type
+ * @param <L> the left element type.
+ * @param <R> the right element type.
* @return the empty array singleton that can be assigned without compiler
warning.
- * @since 3.10.
+ * @since 3.10
*/
@SuppressWarnings("unchecked")
public static <L, R> MutablePair<L, R>[] emptyArray() {
@@ -62,11 +62,11 @@ public static <L, R> MutablePair<L, R>[] emptyArray() {
* <p>This factory allows the pair to be created using inference to
* obtain the generic types.</p>
*
- * @param <L> the left element type
- * @param <R> the right element type
- * @param left the left element, may be null
- * @param right the right element, may be null
- * @return a pair formed from the two parameters, not null
+ * @param <L> the left element type.
+ * @param <R> the right element type.
+ * @param left the left element, may be null.
+ * @param right the right element, may be null.
+ * @return a pair formed from the two parameters, not null.
*/
public static <L, R> MutablePair<L, R> of(final L left, final R right) {
return new MutablePair<>(left, right);
@@ -78,10 +78,10 @@ public static <L, R> MutablePair<L, R> of(final L left,
final R right) {
* <p>This factory allows the pair to be created using inference to
* obtain the generic types.</p>
*
- * @param <L> the left element type
- * @param <R> the right element type
+ * @param <L> the left element type.
+ * @param <R> the right element type.
* @param pair the existing map entry.
- * @return a pair formed from the map entry
+ * @return a pair formed from the map entry.
*/
public static <L, R> MutablePair<L, R> of(final Map.Entry<L, R> pair) {
final L left;
@@ -102,22 +102,22 @@ public static <L, R> MutablePair<L, R> of(final
Map.Entry<L, R> pair) {
* <p>This factory allows the pair to be created using inference to
* obtain the generic types.</p>
*
- * @param <L> the left element type
- * @param <R> the right element type
- * @param left the left element, may not be null
- * @param right the right element, may not be null
- * @return a pair formed from the two parameters, not null
- * @throws NullPointerException if any input is null
+ * @param <L> the left element type.
+ * @param <R> the right element type.
+ * @param left the left element, may not be null.
+ * @param right the right element, may not be null.
+ * @return a pair formed from the two parameters, not null.
+ * @throws NullPointerException if any input is null.
* @since 3.13.0
*/
public static <L, R> MutablePair<L, R> ofNonNull(final L left, final R
right) {
return of(Objects.requireNonNull(left, "left"),
Objects.requireNonNull(right, "right"));
}
- /** Left object */
+ /** Left object. */
public L left;
- /** Right object */
+ /** Right object. */
public R right;
/**
@@ -129,8 +129,8 @@ public MutablePair() {
/**
* Create a new pair instance.
*
- * @param left the left value, may be null
- * @param right the right value, may be null
+ * @param left the left value, may be null.
+ * @param right the right value, may be null.
*/
public MutablePair(final L left, final R right) {
this.left = left;
@@ -156,7 +156,7 @@ public R getRight() {
/**
* Sets the left element of the pair.
*
- * @param left the new value of the left element, may be null
+ * @param left the new value of the left element, may be null.
*/
public void setLeft(final L left) {
this.left = left;
@@ -165,7 +165,7 @@ public void setLeft(final L left) {
/**
* Sets the right element of the pair.
*
- * @param right the new value of the right element, may be null
+ * @param right the new value of the right element, may be null.
*/
public void setRight(final R right) {
this.right = right;
@@ -175,8 +175,8 @@ public void setRight(final R right) {
* Sets the {@code Map.Entry} value.
* This sets the right element of the pair.
*
- * @param value the right value to set, not null
- * @return the old value for the right element
+ * @param value the right value to set, not null.
+ * @return the old value for the right element.
*/
@Override
public R setValue(final R value) {
diff --git a/src/main/java/org/apache/commons/lang3/tuple/MutableTriple.java
b/src/main/java/org/apache/commons/lang3/tuple/MutableTriple.java
index 1b7582e12..165cb2154 100644
--- a/src/main/java/org/apache/commons/lang3/tuple/MutableTriple.java
+++ b/src/main/java/org/apache/commons/lang3/tuple/MutableTriple.java
@@ -23,9 +23,9 @@
*
* <p>Not #ThreadSafe#</p>
*
- * @param <L> the left element type
- * @param <M> the middle element type
- * @param <R> the right element type
+ * @param <L> the left element type.
+ * @param <M> the middle element type.
+ * @param <R> the right element type.
* @since 3.2
*/
public class MutableTriple<L, M, R> extends Triple<L, M, R> {
@@ -36,7 +36,7 @@ public class MutableTriple<L, M, R> extends Triple<L, M, R> {
* Consider using {@link #emptyArray()} to avoid generics warnings.
* </p>
*
- * @since 3.10.
+ * @since 3.10
*/
public static final MutableTriple<?, ?, ?>[] EMPTY_ARRAY = {};
@@ -46,11 +46,11 @@ public class MutableTriple<L, M, R> extends Triple<L, M, R>
{
/**
* Returns the empty array singleton that can be assigned without compiler
warning.
*
- * @param <L> the left element type
- * @param <M> the middle element type
- * @param <R> the right element type
+ * @param <L> the left element type.
+ * @param <M> the middle element type.
+ * @param <R> the right element type.
* @return the empty array singleton that can be assigned without compiler
warning.
- * @since 3.10.
+ * @since 3.10
*/
@SuppressWarnings("unchecked")
public static <L, M, R> MutableTriple<L, M, R>[] emptyArray() {
@@ -63,13 +63,13 @@ public static <L, M, R> MutableTriple<L, M, R>[]
emptyArray() {
* <p>This factory allows the triple to be created using inference to
* obtain the generic types.</p>
*
- * @param <L> the left element type
- * @param <M> the middle element type
- * @param <R> the right element type
- * @param left the left element, may be null
- * @param middle the middle element, may be null
- * @param right the right element, may be null
- * @return a triple formed from the three parameters, not null
+ * @param <L> the left element type.
+ * @param <M> the middle element type.
+ * @param <R> the right element type.
+ * @param left the left element, may be null.
+ * @param middle the middle element, may be null.
+ * @param right the right element, may be null.
+ * @return a triple formed from the three parameters, not null.
*/
public static <L, M, R> MutableTriple<L, M, R> of(final L left, final M
middle, final R right) {
return new MutableTriple<>(left, middle, right);
@@ -81,26 +81,26 @@ public static <L, M, R> MutableTriple<L, M, R> of(final L
left, final M middle,
* <p>This factory allows the triple to be created using inference to
* obtain the generic types.</p>
*
- * @param <L> the left element type
- * @param <M> the middle element type
- * @param <R> the right element type
- * @param left the left element, may not be null
- * @param middle the middle element, may not be null
- * @param right the right element, may not be null
- * @return a triple formed from the three parameters, not null
- * @throws NullPointerException if any input is null
+ * @param <L> the left element type.
+ * @param <M> the middle element type.
+ * @param <R> the right element type.
+ * @param left the left element, may not be null.
+ * @param middle the middle element, may not be null.
+ * @param right the right element, may not be null.
+ * @return a triple formed from the three parameters, not null.
+ * @throws NullPointerException if any input is null.
* @since 3.13.0
*/
public static <L, M, R> MutableTriple<L, M, R> ofNonNull(final L left,
final M middle, final R right) {
return of(Objects.requireNonNull(left, "left"),
Objects.requireNonNull(middle, "middle"), Objects.requireNonNull(right,
"right"));
}
- /** Left object */
+ /** Left object. */
public L left;
- /** Middle object */
+ /** Middle object. */
public M middle;
- /** Right object */
+ /** Right object. */
public R right;
/**
@@ -112,9 +112,9 @@ public MutableTriple() {
/**
* Create a new triple instance.
*
- * @param left the left value, may be null
- * @param middle the middle value, may be null
- * @param right the right value, may be null
+ * @param left the left value, may be null.
+ * @param middle the middle value, may be null.
+ * @param right the right value, may be null.
*/
public MutableTriple(final L left, final M middle, final R right) {
this.left = left;
@@ -149,7 +149,7 @@ public R getRight() {
/**
* Sets the left element of the triple.
*
- * @param left the new value of the left element, may be null
+ * @param left the new value of the left element, may be null.
*/
public void setLeft(final L left) {
this.left = left;
@@ -158,7 +158,7 @@ public void setLeft(final L left) {
/**
* Sets the middle element of the triple.
*
- * @param middle the new value of the middle element, may be null
+ * @param middle the new value of the middle element, may be null.
*/
public void setMiddle(final M middle) {
this.middle = middle;
@@ -167,7 +167,7 @@ public void setMiddle(final M middle) {
/**
* Sets the right element of the triple.
*
- * @param right the new value of the right element, may be null
+ * @param right the new value of the right element, may be null.
*/
public void setRight(final R right) {
this.right = right;
diff --git a/src/main/java/org/apache/commons/lang3/tuple/Pair.java
b/src/main/java/org/apache/commons/lang3/tuple/Pair.java
index 722d4ac2c..bcb2d88e3 100644
--- a/src/main/java/org/apache/commons/lang3/tuple/Pair.java
+++ b/src/main/java/org/apache/commons/lang3/tuple/Pair.java
@@ -35,8 +35,8 @@
* However, there is no restriction on the type of the stored objects that may
be stored.
* If mutable objects are stored in the pair, then the pair itself effectively
becomes mutable.</p>
*
- * @param <L> the left element type
- * @param <R> the right element type
+ * @param <L> the left element type.
+ * @param <R> the right element type.
* @since 3.0
*/
public abstract class Pair<L, R> implements Map.Entry<L, R>,
Comparable<Pair<L, R>>, Serializable {
@@ -50,17 +50,17 @@ public abstract class Pair<L, R> implements Map.Entry<L,
R>, Comparable<Pair<L,
* Consider using {@link #emptyArray()} to avoid generics warnings.
* </p>
*
- * @since 3.10.
+ * @since 3.10
*/
public static final Pair<?, ?>[] EMPTY_ARRAY = {};
/**
* Returns the empty array singleton that can be assigned without compiler
warning.
*
- * @param <L> the left element type
- * @param <R> the right element type
+ * @param <L> the left element type.
+ * @param <R> the right element type.
* @return the empty array singleton that can be assigned without compiler
warning.
- * @since 3.10.
+ * @since 3.10
*/
@SuppressWarnings("unchecked")
public static <L, R> Pair<L, R>[] emptyArray() {
@@ -73,11 +73,11 @@ public static <L, R> Pair<L, R>[] emptyArray() {
* <p>This factory allows the pair to be created using inference to
* obtain the generic types.</p>
*
- * @param <L> the left element type
- * @param <R> the right element type
- * @param left the left element, may be null
- * @param right the right element, may be null
- * @return a pair formed from the two parameters, not null
+ * @param <L> the left element type.
+ * @param <R> the right element type.
+ * @param left the left element, may be null.
+ * @param right the right element, may be null.
+ * @return a pair formed from the two parameters, not null.
*/
public static <L, R> Pair<L, R> of(final L left, final R right) {
return ImmutablePair.of(left, right);
@@ -89,10 +89,10 @@ public static <L, R> Pair<L, R> of(final L left, final R
right) {
* <p>This factory allows the pair to be created using inference to
* obtain the generic types.</p>
*
- * @param <L> the left element type
- * @param <R> the right element type
+ * @param <L> the left element type.
+ * @param <R> the right element type.
* @param pair the map entry.
- * @return a pair formed from the map entry
+ * @return a pair formed from the map entry.
* @since 3.10
*/
public static <L, R> Pair<L, R> of(final Map.Entry<L, R> pair) {
@@ -105,12 +105,12 @@ public static <L, R> Pair<L, R> of(final Map.Entry<L, R>
pair) {
* <p>This factory allows the pair to be created using inference to
* obtain the generic types.</p>
*
- * @param <L> the left element type
- * @param <R> the right element type
- * @param left the left element, may not be null
- * @param right the right element, may not be null
- * @return a pair formed from the two parameters, not null
- * @throws NullPointerException if any input is null
+ * @param <L> the left element type.
+ * @param <R> the right element type.
+ * @param left the left element, may not be null.
+ * @param right the right element, may not be null.
+ * @return a pair formed from the two parameters, not null.
+ * @throws NullPointerException if any input is null.
* @since 3.13.0
*/
public static <L, R> Pair<L, R> ofNonNull(final L left, final R right) {
@@ -154,8 +154,8 @@ public <V, E extends Throwable> V apply(final
FailableBiFunction<L, R, V, E> fun
* Compares the pair based on the left element followed by the right
element.
* The types must be {@link Comparable}.
*
- * @param other the other pair, not null
- * @return negative if this is less, zero if equal, positive if greater
+ * @param other the other pair, not null.
+ * @return negative if this is less, zero if equal, positive if greater.
*/
@Override
public int compareTo(final Pair<L, R> other) {
@@ -170,8 +170,8 @@ public int compareTo(final Pair<L, R> other) {
/**
* Compares this pair to another based on the two elements.
*
- * @param obj the object to compare to, null returns false
- * @return true if the elements of the pair are equal
+ * @param obj the object to compare to, null returns false.
+ * @return true if the elements of the pair are equal.
*/
@Override
public boolean equals(final Object obj) {
@@ -192,7 +192,7 @@ public boolean equals(final Object obj) {
* <p>This method implements the {@code Map.Entry} interface returning the
* left element as the key.</p>
*
- * @return the left element as the key, may be null
+ * @return the left element as the key, may be null.
*/
@Override
public final L getKey() {
@@ -204,7 +204,7 @@ public final L getKey() {
*
* <p>When treated as a key-value pair, this is the key.</p>
*
- * @return the left element, may be null
+ * @return the left element, may be null.
*/
public abstract L getLeft();
@@ -213,7 +213,7 @@ public final L getKey() {
*
* <p>When treated as a key-value pair, this is the value.</p>
*
- * @return the right element, may be null
+ * @return the right element, may be null.
*/
public abstract R getRight();
@@ -223,7 +223,7 @@ public final L getKey() {
* <p>This method implements the {@code Map.Entry} interface returning the
* right element as the value.</p>
*
- * @return the right element as the value, may be null
+ * @return the right element as the value, may be null.
*/
@Override
public R getValue() {
@@ -245,9 +245,9 @@ public int hashCode() {
}
/**
- * Returns a String representation of this pair using the format {@code
($left,$right)}.
+ * Returns a String representation of this pair using the format {@code
(left,right)}.
*
- * @return a string describing this object, not null
+ * @return a string describing this object, not null.
*/
@Override
public String toString() {
@@ -263,7 +263,7 @@ public String toString() {
* </p>
*
* @param format the format string, optionally containing {@code %1$s} and
{@code %2$s}, not null.
- * @return the formatted string, not null
+ * @return the formatted string, not null.
* @see String#format(String, Object...)
*/
public String toString(final String format) {
diff --git a/src/main/java/org/apache/commons/lang3/tuple/Triple.java
b/src/main/java/org/apache/commons/lang3/tuple/Triple.java
index ac68e29cf..aa839f7ef 100644
--- a/src/main/java/org/apache/commons/lang3/tuple/Triple.java
+++ b/src/main/java/org/apache/commons/lang3/tuple/Triple.java
@@ -31,9 +31,9 @@
* However, there is no restriction on the type of the stored objects that may
be stored.
* If mutable objects are stored in the triple, then the triple itself
effectively becomes mutable.</p>
*
- * @param <L> the left element type
- * @param <M> the middle element type
- * @param <R> the right element type
+ * @param <L> the left element type.
+ * @param <M> the middle element type.
+ * @param <R> the right element type.
* @since 3.2
*/
public abstract class Triple<L, M, R> implements Comparable<Triple<L, M, R>>,
Serializable {
@@ -47,18 +47,18 @@ public abstract class Triple<L, M, R> implements
Comparable<Triple<L, M, R>>, Se
* Consider using {@link #emptyArray()} to avoid generics warnings.
* </p>
*
- * @since 3.10.
+ * @since 3.10
*/
public static final Triple<?, ?, ?>[] EMPTY_ARRAY = {};
/**
* Returns the empty array singleton that can be assigned without compiler
warning.
*
- * @param <L> the left element type
- * @param <M> the middle element type
- * @param <R> the right element type
+ * @param <L> the left element type.
+ * @param <M> the middle element type.
+ * @param <R> the right element type.
* @return the empty array singleton that can be assigned without compiler
warning.
- * @since 3.10.
+ * @since 3.10
*/
@SuppressWarnings("unchecked")
public static <L, M, R> Triple<L, M, R>[] emptyArray() {
@@ -71,13 +71,13 @@ public static <L, M, R> Triple<L, M, R>[] emptyArray() {
* <p>This factory allows the triple to be created using inference to
* obtain the generic types.</p>
*
- * @param <L> the left element type
- * @param <M> the middle element type
- * @param <R> the right element type
- * @param left the left element, may be null
- * @param middle the middle element, may be null
- * @param right the right element, may be null
- * @return a triple formed from the three parameters, not null
+ * @param <L> the left element type.
+ * @param <M> the middle element type.
+ * @param <R> the right element type.
+ * @param left the left element, may be null.
+ * @param middle the middle element, may be null.
+ * @param right the right element, may be null.
+ * @return a triple formed from the three parameters, not null.
*/
public static <L, M, R> Triple<L, M, R> of(final L left, final M middle,
final R right) {
return ImmutableTriple.of(left, middle, right);
@@ -89,14 +89,14 @@ public static <L, M, R> Triple<L, M, R> of(final L left,
final M middle, final R
* <p>This factory allows the triple to be created using inference to
* obtain the generic types.</p>
*
- * @param <L> the left element type
- * @param <M> the middle element type
- * @param <R> the right element type
- * @param left the left element, may not be null
- * @param middle the middle element, may not be null
- * @param right the right element, may not be null
- * @return a triple formed from the three parameters, not null
- * @throws NullPointerException if any input is null
+ * @param <L> the left element type.
+ * @param <M> the middle element type.
+ * @param <R> the right element type.
+ * @param left the left element, may not be null.
+ * @param middle the middle element, may not be null.
+ * @param right the right element, may not be null.
+ * @return a triple formed from the three parameters, not null.
+ * @throws NullPointerException if any input is null.
* @since 3.13.0
*/
public static <L, M, R> Triple<L, M, R> ofNonNull(final L left, final M
middle, final R right) {
@@ -115,8 +115,8 @@ public Triple() {
* finally the right element.
* The types must be {@link Comparable}.
*
- * @param other the other triple, not null
- * @return negative if this is less, zero if equal, positive if greater
+ * @param other the other triple, not null.
+ * @return negative if this is less, zero if equal, positive if greater.
*/
@Override
public int compareTo(final Triple<L, M, R> other) {
@@ -128,8 +128,8 @@ public int compareTo(final Triple<L, M, R> other) {
/**
* Compares this triple to another based on the three elements.
*
- * @param obj the object to compare to, null returns false
- * @return true if the elements of the triple are equal
+ * @param obj the object to compare to, null returns false.
+ * @return true if the elements of the triple are equal.
*/
@Override
public boolean equals(final Object obj) {
@@ -148,21 +148,21 @@ public boolean equals(final Object obj) {
/**
* Gets the left element from this triple.
*
- * @return the left element, may be null
+ * @return the left element, may be null.
*/
public abstract L getLeft();
/**
* Gets the middle element from this triple.
*
- * @return the middle element, may be null
+ * @return the middle element, may be null.
*/
public abstract M getMiddle();
/**
* Gets the right element from this triple.
*
- * @return the right element, may be null
+ * @return the right element, may be null.
*/
public abstract R getRight();
@@ -181,9 +181,9 @@ public int hashCode() {
}
/**
- * Returns a String representation of this triple using the format {@code
($left,$middle,$right)}.
+ * Returns a String representation of this triple using the format {@code
(left,middle,right)}.
*
- * @return a string describing this object, not null
+ * @return a string describing this object, not null.
*/
@Override
public String toString() {
@@ -198,8 +198,8 @@ public String toString() {
* element, {@code %2$s} for the middle and {@code %3$s} for the right
element.
* The default format used by {@code toString()} is {@code
(%1$s,%2$s,%3$s)}.</p>
*
- * @param format the format string, optionally containing {@code %1$s},
{@code %2$s} and {@code %3$s}, not null
- * @return the formatted string, not null
+ * @param format the format string, optionally containing {@code %1$s},
{@code %2$s} and {@code %3$s}, not null.
+ * @return the formatted string, not null.
*/
public String toString(final String format) {
return String.format(format, getLeft(), getMiddle(), getRight());
