More nullity annotations and other fixes for Tuples.

Author: GlenKPeterson

src/main/java/org/organicdesign/fp/tuple/Tuple10.java

@@ -14,6 +14,8 @@
 
 package org.organicdesign.fp.tuple;
 
+import org.jetbrains.annotations.NotNull;
+
 import java.io.Serializable;
 import java.util.Objects;
 
@@ -24,18 +26,19 @@
 // ======================================================================================
 
 /**
- Holds 10 items of potentially different types.  Designed to let you easily create immutable
- subclasses (to give your data structures meaningful names) with correct equals(), hashCode(), and
- toString() methods.
+ * Holds 10 items of potentially different types.  Designed to let you easily create immutable
+ * subclasses (to give your data structures meaningful names) with correct equals(), hashCode(), and
+ * toString() methods.
  */
 public class Tuple10<A,B,C,D,E,F,G,H,I,J> implements Serializable {
 
     // For serializable.  Make sure to change whenever internal data format changes.
-    // Implemented because implementing serializable only on a sub-class of an
+    // Implemented because implementing serializable only on a subclass of an
     // immutable class requires a serialization proxy.  That's probably worse than
-    // the conceptual burdeon of all tuples being Serializable.    private static final long serialVersionUID = 20160906065500L;
+    // the conceptual burden of all tuples being Serializable.
+    private static final long serialVersionUID = 20211228180200L;
 
-    // Fields are protected so that sub-classes can make accessor methods with meaningful names.
+    // Fields are protected so that subclasses can make accessor methods with meaningful names.
     protected final A _1;
     protected final B _2;
     protected final C _3;
@@ -48,19 +51,19 @@ public class Tuple10<A,B,C,D,E,F,G,H,I,J> implements Serializable {
     protected final J _10;
 
     /**
-     Constructor is protected (not public) for easy inheritance.  Josh Bloch's "Item 1" says public
-     static factory methods are better than constructors because they have names, they can return
-     an existing object instead of a new one, and they can return a sub-type.  Therefore, you
-     have more flexibility with a static factory as part of your public API then with a public
-     constructor.
+     * Constructor is protected (not public) for easy inheritance.  Josh Bloch's "Item 1" says public
+     * static factory methods are better than constructors because they have names, they can return
+     * an existing object instead of a new one, and they can return a subtype.  Therefore, you
+     * have more flexibility with a static factory as part of your public API then with a public
+     * constructor.
      */
     protected Tuple10(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j) {
         _1 = a; _2 = b; _3 = c; _4 = d; _5 = e; _6 = f; _7 = g; _8 = h; _9 = i;
         _10 = j;
     }
 
     /** Public static factory method */
-    public static <A,B,C,D,E,F,G,H,I,J> Tuple10<A,B,C,D,E,F,G,H,I,J>
+    public static <A,B,C,D,E,F,G,H,I,J> @NotNull Tuple10<A,B,C,D,E,F,G,H,I,J>
     of(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j) {
         return new Tuple10<>(a, b, c, d, e, f, g, h, i, j);
     }
@@ -87,7 +90,7 @@ protected Tuple10(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j) {
     public J _10() { return _10; }
 
     @Override
-    public String toString() {
+    public @NotNull String toString() {
         return getClass().getSimpleName() + "(" +
                stringify(_1) + "," + stringify(_2) + "," +
                stringify(_3) + "," + stringify(_4) + "," + stringify(_5) + "," +

src/main/java/org/organicdesign/fp/tuple/Tuple11.java

@@ -14,6 +14,8 @@
 
 package org.organicdesign.fp.tuple;
 
+import org.jetbrains.annotations.NotNull;
+
 import java.io.Serializable;
 import java.util.Objects;
 
@@ -24,18 +26,19 @@
 // ======================================================================================
 
 /**
- Holds 11 items of potentially different types.  Designed to let you easily create immutable
- subclasses (to give your data structures meaningful names) with correct equals(), hashCode(), and
- toString() methods.
+ * Holds 11 items of potentially different types.  Designed to let you easily create immutable
+ * subclasses (to give your data structures meaningful names) with correct equals(), hashCode(), and
+ * toString() methods.
  */
 public class Tuple11<A,B,C,D,E,F,G,H,I,J,K> implements Serializable {
 
     // For serializable.  Make sure to change whenever internal data format changes.
-    // Implemented because implementing serializable only on a sub-class of an
+    // Implemented because implementing serializable only on a subclass of an
     // immutable class requires a serialization proxy.  That's probably worse than
-    // the conceptual burdeon of all tuples being Serializable.    private static final long serialVersionUID = 20160906065500L;
+    // the conceptual burden of all tuples being Serializable.
+    private static final long serialVersionUID = 20211228180200L;
 
-    // Fields are protected so that sub-classes can make accessor methods with meaningful names.
+    // Fields are protected so that subclasses can make accessor methods with meaningful names.
     protected final A _1;
     protected final B _2;
     protected final C _3;
@@ -49,19 +52,19 @@ public class Tuple11<A,B,C,D,E,F,G,H,I,J,K> implements Serializable {
     protected final K _11;
 
     /**
-     Constructor is protected (not public) for easy inheritance.  Josh Bloch's "Item 1" says public
-     static factory methods are better than constructors because they have names, they can return
-     an existing object instead of a new one, and they can return a sub-type.  Therefore, you
-     have more flexibility with a static factory as part of your public API then with a public
-     constructor.
+     * Constructor is protected (not public) for easy inheritance.  Josh Bloch's "Item 1" says public
+     * static factory methods are better than constructors because they have names, they can return
+     * an existing object instead of a new one, and they can return a subtype.  Therefore, you
+     * have more flexibility with a static factory as part of your public API then with a public
+     * constructor.
      */
     protected Tuple11(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k) {
         _1 = a; _2 = b; _3 = c; _4 = d; _5 = e; _6 = f; _7 = g; _8 = h; _9 = i;
         _10 = j; _11 = k;
     }
 
     /** Public static factory method */
-    public static <A,B,C,D,E,F,G,H,I,J,K> Tuple11<A,B,C,D,E,F,G,H,I,J,K>
+    public static <A,B,C,D,E,F,G,H,I,J,K> @NotNull Tuple11<A,B,C,D,E,F,G,H,I,J,K>
     of(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k) {
         return new Tuple11<>(a, b, c, d, e, f, g, h, i, j, k);
     }
@@ -90,7 +93,7 @@ protected Tuple11(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k) {
     public K _11() { return _11; }
 
     @Override
-    public String toString() {
+    public @NotNull String toString() {
         return getClass().getSimpleName() + "(" +
                stringify(_1) + "," + stringify(_2) + "," +
                stringify(_3) + "," + stringify(_4) + "," + stringify(_5) + "," +

src/main/java/org/organicdesign/fp/tuple/Tuple12.java

@@ -14,6 +14,8 @@
 
 package org.organicdesign.fp.tuple;
 
+import org.jetbrains.annotations.NotNull;
+
 import java.io.Serializable;
 import java.util.Objects;
 
@@ -24,18 +26,19 @@
 // ======================================================================================
 
 /**
- Holds 12 items of potentially different types.  Designed to let you easily create immutable
- subclasses (to give your data structures meaningful names) with correct equals(), hashCode(), and
- toString() methods.
+ * Holds 12 items of potentially different types.  Designed to let you easily create immutable
+ * subclasses (to give your data structures meaningful names) with correct equals(), hashCode(), and
+ * toString() methods.
  */
 public class Tuple12<A,B,C,D,E,F,G,H,I,J,K,L> implements Serializable {
 
     // For serializable.  Make sure to change whenever internal data format changes.
-    // Implemented because implementing serializable only on a sub-class of an
+    // Implemented because implementing serializable only on a subclass of an
     // immutable class requires a serialization proxy.  That's probably worse than
-    // the conceptual burdeon of all tuples being Serializable.    private static final long serialVersionUID = 20160906065500L;
+    // the conceptual burden of all tuples being Serializable.
+    private static final long serialVersionUID = 20211228180200L;
 
-    // Fields are protected so that sub-classes can make accessor methods with meaningful names.
+    // Fields are protected so that subclasses can make accessor methods with meaningful names.
     protected final A _1;
     protected final B _2;
     protected final C _3;
@@ -50,19 +53,19 @@ public class Tuple12<A,B,C,D,E,F,G,H,I,J,K,L> implements Serializable {
     protected final L _12;
 
     /**
-     Constructor is protected (not public) for easy inheritance.  Josh Bloch's "Item 1" says public
-     static factory methods are better than constructors because they have names, they can return
-     an existing object instead of a new one, and they can return a sub-type.  Therefore, you
-     have more flexibility with a static factory as part of your public API then with a public
-     constructor.
+     * Constructor is protected (not public) for easy inheritance.  Josh Bloch's "Item 1" says public
+     * static factory methods are better than constructors because they have names, they can return
+     * an existing object instead of a new one, and they can return a subtype.  Therefore, you
+     * have more flexibility with a static factory as part of your public API then with a public
+     * constructor.
      */
     protected Tuple12(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l) {
         _1 = a; _2 = b; _3 = c; _4 = d; _5 = e; _6 = f; _7 = g; _8 = h; _9 = i;
         _10 = j; _11 = k; _12 = l;
     }
 
     /** Public static factory method */
-    public static <A,B,C,D,E,F,G,H,I,J,K,L> Tuple12<A,B,C,D,E,F,G,H,I,J,K,L>
+    public static <A,B,C,D,E,F,G,H,I,J,K,L> @NotNull Tuple12<A,B,C,D,E,F,G,H,I,J,K,L>
     of(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l) {
         return new Tuple12<>(a, b, c, d, e, f, g, h, i, j, k, l);
     }
@@ -93,7 +96,7 @@ protected Tuple12(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l) {
     public L _12() { return _12; }
 
     @Override
-    public String toString() {
+    public @NotNull String toString() {
         return getClass().getSimpleName() + "(" +
                stringify(_1) + "," + stringify(_2) + "," +
                stringify(_3) + "," + stringify(_4) + "," + stringify(_5) + "," +

src/main/java/org/organicdesign/fp/tuple/Tuple3.java

@@ -14,6 +14,8 @@
 
 package org.organicdesign.fp.tuple;
 
+import org.jetbrains.annotations.NotNull;
+
 import java.io.Serializable;
 import java.util.Objects;
 
@@ -24,35 +26,36 @@
 // ======================================================================================
 
 /**
- Holds 3 items of potentially different types.  Designed to let you easily create immutable
- subclasses (to give your data structures meaningful names) with correct equals(), hashCode(), and
- toString() methods.
+ * Holds 3 items of potentially different types.  Designed to let you easily create immutable
+ * subclasses (to give your data structures meaningful names) with correct equals(), hashCode(), and
+ * toString() methods.
  */
 public class Tuple3<A,B,C> implements Serializable {
 
     // For serializable.  Make sure to change whenever internal data format changes.
-    // Implemented because implementing serializable only on a sub-class of an
+    // Implemented because implementing serializable only on a subclass of an
     // immutable class requires a serialization proxy.  That's probably worse than
-    // the conceptual burdeon of all tuples being Serializable.    private static final long serialVersionUID = 20160906065500L;
+    // the conceptual burden of all tuples being Serializable.
+    private static final long serialVersionUID = 20211228180200L;
 
-    // Fields are protected so that sub-classes can make accessor methods with meaningful names.
+    // Fields are protected so that subclasses can make accessor methods with meaningful names.
     protected final A _1;
     protected final B _2;
     protected final C _3;
 
     /**
-     Constructor is protected (not public) for easy inheritance.  Josh Bloch's "Item 1" says public
-     static factory methods are better than constructors because they have names, they can return
-     an existing object instead of a new one, and they can return a sub-type.  Therefore, you
-     have more flexibility with a static factory as part of your public API then with a public
-     constructor.
+     * Constructor is protected (not public) for easy inheritance.  Josh Bloch's "Item 1" says public
+     * static factory methods are better than constructors because they have names, they can return
+     * an existing object instead of a new one, and they can return a subtype.  Therefore, you
+     * have more flexibility with a static factory as part of your public API then with a public
+     * constructor.
      */
     protected Tuple3(A a, B b, C c) {
         _1 = a; _2 = b; _3 = c;
     }
 
     /** Public static factory method */
-    public static <A,B,C> Tuple3<A,B,C> of(A a, B b, C c) {
+    public static <A,B,C> @NotNull Tuple3<A,B,C> of(A a, B b, C c) {
         return new Tuple3<>(a, b, c);
     }
 
@@ -64,7 +67,7 @@ public static <A,B,C> Tuple3<A,B,C> of(A a, B b, C c) {
     public C _3() { return _3; }
 
     @Override
-    public String toString() {
+    public @NotNull String toString() {
         return getClass().getSimpleName() + "(" +
                stringify(_1) + "," + stringify(_2) + "," +
                stringify(_3) + ")";

src/main/java/org/organicdesign/fp/tuple/Tuple4.java

@@ -14,6 +14,8 @@
 
 package org.organicdesign.fp.tuple;
 
+import org.jetbrains.annotations.NotNull;
+
 import java.io.Serializable;
 import java.util.Objects;
 
@@ -24,36 +26,37 @@
 // ======================================================================================
 
 /**
- Holds 4 items of potentially different types.  Designed to let you easily create immutable
- subclasses (to give your data structures meaningful names) with correct equals(), hashCode(), and
- toString() methods.
+ * Holds 4 items of potentially different types.  Designed to let you easily create immutable
+ * subclasses (to give your data structures meaningful names) with correct equals(), hashCode(), and
+ * toString() methods.
  */
 public class Tuple4<A,B,C,D> implements Serializable {
 
     // For serializable.  Make sure to change whenever internal data format changes.
-    // Implemented because implementing serializable only on a sub-class of an
+    // Implemented because implementing serializable only on a subclass of an
     // immutable class requires a serialization proxy.  That's probably worse than
-    // the conceptual burdeon of all tuples being Serializable.    private static final long serialVersionUID = 20160906065500L;
+    // the conceptual burden of all tuples being Serializable.
+    private static final long serialVersionUID = 20211228180200L;
 
-    // Fields are protected so that sub-classes can make accessor methods with meaningful names.
+    // Fields are protected so that subclasses can make accessor methods with meaningful names.
     protected final A _1;
     protected final B _2;
     protected final C _3;
     protected final D _4;
 
     /**
-     Constructor is protected (not public) for easy inheritance.  Josh Bloch's "Item 1" says public
-     static factory methods are better than constructors because they have names, they can return
-     an existing object instead of a new one, and they can return a sub-type.  Therefore, you
-     have more flexibility with a static factory as part of your public API then with a public
-     constructor.
+     * Constructor is protected (not public) for easy inheritance.  Josh Bloch's "Item 1" says public
+     * static factory methods are better than constructors because they have names, they can return
+     * an existing object instead of a new one, and they can return a subtype.  Therefore, you
+     * have more flexibility with a static factory as part of your public API then with a public
+     * constructor.
      */
     protected Tuple4(A a, B b, C c, D d) {
         _1 = a; _2 = b; _3 = c; _4 = d;
     }
 
     /** Public static factory method */
-    public static <A,B,C,D> Tuple4<A,B,C,D> of(A a, B b, C c, D d) {
+    public static <A,B,C,D> @NotNull Tuple4<A,B,C,D> of(A a, B b, C c, D d) {
         return new Tuple4<>(a, b, c, d);
     }
 
@@ -67,7 +70,7 @@ public static <A,B,C,D> Tuple4<A,B,C,D> of(A a, B b, C c, D d) {
     public D _4() { return _4; }
 
     @Override
-    public String toString() {
+    public @NotNull String toString() {
         return getClass().getSimpleName() + "(" +
                stringify(_1) + "," + stringify(_2) + "," +
                stringify(_3) + "," + stringify(_4) + ")";