Javadoc

Author: garydgregory

src/main/java/org/apache/commons/lang3/tuple/ImmutablePair.java

@@ -70,10 +70,10 @@ public static <L, R> ImmutablePair<L, R>[] emptyArray() {
     /**
      * Creates an immutable pair of two objects inferring the generic types.
      *
-     * @param <L> the left element type
-     * @param <R> the right element type
-     * @param left  the left 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.
+     * @return an immutable formed from the two parameters, not null.
      * @since 3.11
      */
     public static <L, R> Pair<L, R> left(final L left) {
@@ -96,11 +96,11 @@ public static <L, R> ImmutablePair<L, R> nullPair() {
     /**
      * Creates an immutable pair of two objects inferring the generic types.
      *
-     * @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 an immutable formed from the two parameters, not null.
      */
     public static <L, R> ImmutablePair<L, R> of(final L left, final R right) {
         return left != null || right != null ? new ImmutablePair<>(left, right) : nullPair();
@@ -109,10 +109,10 @@ public static <L, R> ImmutablePair<L, R> of(final L left, final R right) {
     /**
      * Creates an immutable pair from a map entry.
      *
-     * @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 an immutable formed from the map entry.
      * @since 3.10
      */
     public static <L, R> ImmutablePair<L, R> of(final Map.Entry<L, R> pair) {
@@ -122,12 +122,12 @@ public static <L, R> ImmutablePair<L, R> of(final Map.Entry<L, R> pair) {
     /**
      * Creates an immutable pair of two non-null objects inferring the generic types.
      *
-     * @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 an immutable formed from the two parameters, not null.
+     * @throws NullPointerException if any input is null.
      * @since 3.13.0
      */
     public static <L, R> ImmutablePair<L, R> ofNonNull(final L left, final R right) {
@@ -137,10 +137,10 @@ public static <L, R> ImmutablePair<L, R> ofNonNull(final L left, final R right)
     /**
      * Creates an immutable pair of two objects inferring the generic types.
      *
-     * @param <L> the left element type
-     * @param <R> the right element type
-     * @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 right  the right element, may be null.
+     * @return an immutable formed from the two parameters, not null.
      * @since 3.11
      */
     public static <L, R> Pair<L, R> right(final R right) {

src/main/java/org/apache/commons/lang3/tuple/ImmutableTriple.java

@@ -91,7 +91,7 @@ public static <L, M, R> ImmutableTriple<L, M, R> nullTriple() {
      * @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.
+     * @return an immutable 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();
@@ -106,7 +106,7 @@ public static <L, M, R> ImmutableTriple<L, M, R> of(final L left, final M middle
      * @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.
+     * @return an immutable triple formed from the three parameters, not null.
      * @throws NullPointerException if any input is null.
      * @since 3.13.0
      */

src/main/java/org/apache/commons/lang3/tuple/MutablePair.java

@@ -63,7 +63,7 @@ public static <L, R> MutablePair<L, R>[] emptyArray() {
      * @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.
+     * @return a mutable 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);
@@ -75,7 +75,7 @@ public static <L, R> MutablePair<L, R> of(final L left, final R right) {
      * @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 mutable pair formed from the map entry.
      */
     public static <L, R> MutablePair<L, R> of(final Map.Entry<L, R> pair) {
         final L left;
@@ -97,7 +97,7 @@ public static <L, R> MutablePair<L, R> of(final Map.Entry<L, R> pair) {
      * @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.
+     * @return a mutable pair formed from the two parameters, not null.
      * @throws NullPointerException if any input is null.
      * @since 3.13.0
      */

src/main/java/org/apache/commons/lang3/tuple/MutableTriple.java

@@ -66,7 +66,7 @@ public static <L, M, R> MutableTriple<L, M, R>[] emptyArray() {
      * @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.
+     * @return a mutable 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,7 +81,7 @@ public static <L, M, R> MutableTriple<L, M, R> of(final L left, final M middle,
      * @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.
+     * @return a mutable triple formed from the three parameters, not null.
      * @throws NullPointerException if any input is null.
      * @since 3.13.0
      */