Johannes/java-commons
Johannes
/
java-commons
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat(commons): extend tuple API

This commit is contained in:
Johannes Frohnmeyer 2024-05-04 22:41:06 +02:00
parent bfc72b4428
commit f66a7b5656
Signed by: Johannes
GPG Key ID: E76429612C2929F4
4 changed files with 127 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
commons/src/main/java/io/gitlab/jfronny/commons/tuple/Quadruple.java
View File

@ -17,10 +17,26 @@ public record Quadruple<T1, T2, T3, T4>(@Nullable T1 val1, @Nullable T2 val2, @N
}
@Contract(value = "-> new", pure = true)
@Deprecated(forRemoval = true)
public @NotNull Tuple<Tuple<T1, T2>, Tuple<T3, T4>> slice() {
return slice2();
}
@Contract(value = "-> new", pure = true)
public @NotNull Tuple<T1, Triple<T2, T3, T4>> slice1() {
return new Tuple<>(val1, new Triple<>(val2, val3, val4));
}
@Contract(value = "-> new", pure = true)
public @NotNull Tuple<Tuple<T1, T2>, Tuple<T3, T4>> slice2() {
return new Tuple<>(new Tuple<>(val1, val2), new Tuple<>(val3, val4));
}
@Contract(value = "-> new", pure = true)
public @NotNull Tuple<Triple<T1, T2, T3>, T4> slice3() {
return new Tuple<>(new Triple<>(val1, val2, val3), val4);
}
@Contract(value = "_ -> new", pure = true)
public <T> @NotNull Quadruple<T, T2, T3, T4> map1(@NotNull Function<T1, T> mapper) {
return new Quadruple<>(Objects.requireNonNull(mapper).apply(val1), val2, val3, val4);
@ -40,4 +56,34 @@ public record Quadruple<T1, T2, T3, T4>(@Nullable T1 val1, @Nullable T2 val2, @N
public <T> @NotNull Quadruple<T1, T2, T3, T> map4(@NotNull Function<T4, T> mapper) {
return new Quadruple<>(val1, val2, val3, Objects.requireNonNull(mapper).apply(val4));
}
@Contract(value = "-> new", pure = true)
public @NotNull Quadruple<T2, T1, T3, T4> swap12() {
return new Quadruple<>(val2, val1, val3, val4);
}
@Contract(value = "-> new", pure = true)
public @NotNull Quadruple<T3, T2, T1, T4> swap13() {
return new Quadruple<>(val3, val2, val1, val4);
}
@Contract(value = "-> new", pure = true)
public @NotNull Quadruple<T4, T2, T3, T1> swap14() {
return new Quadruple<>(val4, val2, val3, val1);
}
@Contract(value = "-> new", pure = true)
public @NotNull Quadruple<T1, T3, T2, T4> swap23() {
return new Quadruple<>(val1, val3, val2, val4);
}
@Contract(value = "-> new", pure = true)
public @NotNull Quadruple<T1, T4, T3, T2> swap24() {
return new Quadruple<>(val1, val4, val3, val2);
}
@Contract(value = "-> new", pure = true)
public @NotNull Quadruple<T1, T2, T4, T3> swap34() {
return new Quadruple<>(val1, val2, val4, val3);
}
}

37
commons/src/main/java/io/gitlab/jfronny/commons/tuple/Single.java
View File

@ -28,8 +28,13 @@ public record Single<T1>(@Nullable T1 val) {
return val == null ? Objects::isNull : val::equals;
}
@Deprecated(forRemoval = true)
public ThrowingPredicate<T1, RuntimeException> asInstanceEqualsPredicate() {
return asIdentityEqualsPredicate();
}
@Contract(value = "-> new", pure = true)
public @NotNull ThrowingPredicate<T1, RuntimeException> asInstanceEqualsPredicate() {
public @NotNull ThrowingPredicate<T1, RuntimeException> asIdentityEqualsPredicate() {
return v -> v == val;
}
@ -47,4 +52,34 @@ public record Single<T1>(@Nullable T1 val) {
public @Nullable T1 get() {
return val;
}
@Contract(value = "_ -> new", pure = true)
public <T2> @NotNull Tuple<T1, T2> concat(@Nullable T2 val) {
return Tuple.of(this.val, val);
}
@Contract(value = "_, _ -> new", pure = true)
public <T2, T3> @NotNull Triple<T1, T2, T3> concat(@Nullable T2 val2, @Nullable T3 val3) {
return Triple.of(this.val, val2, val3);
}
@Contract(value = "_, _, _ -> new", pure = true)
public <T2, T3, T4> @NotNull Quadruple<T1, T2, T3, T4> concat(@Nullable T2 val2, @Nullable T3 val3, @Nullable T4 val4) {
return Quadruple.of(this.val, val2, val3, val4);
}
@Contract(value = "_ -> new", pure = true)
public <T2> @NotNull Tuple<T1, T2> concat(@NotNull Single<T2> val) {
return Tuple.of(this.val, val.val);
}
@Contract(value = "_ -> new", pure = true)
public <T2, T3> @NotNull Triple<T1, T2, T3> concat(@NotNull Tuple<T2, T3> val) {
return Triple.of(this.val, val.left(), val.right());
}
@Contract(value = "_ -> new", pure = true)
public <T2, T3, T4> @NotNull Quadruple<T1, T2, T3, T4> concat(@NotNull Triple<T2, T3, T4> val) {
return Quadruple.of(this.val, val.val1(), val.val2(), val.val3());
}
}

20
commons/src/main/java/io/gitlab/jfronny/commons/tuple/Triple.java
View File

@ -26,6 +26,16 @@ public record Triple<T1, T2, T3>(@Nullable T1 val1, @Nullable T2 val2, @Nullable
return new Triple<>(val1, val2, Objects.requireNonNull(mapper).apply(val3));
}
@Contract(value = "-> new", pure = true)
public @NotNull Tuple<T1, Tuple<T2, T3>> slice1() {
return Tuple.of(val1, Tuple.of(val2, val3));
}
@Contract(value = "-> new", pure = true)
public @NotNull Tuple<Tuple<T1, T2>, T3> slice2() {
return Tuple.of(Tuple.of(val1, val2), val3);
}
@Contract(value = "-> new", pure = true)
public @NotNull Triple<T2, T3, T1> lShift() {
return new Triple<>(val2, val3, val1);
@ -50,4 +60,14 @@ public record Triple<T1, T2, T3>(@Nullable T1 val1, @Nullable T2 val2, @Nullable
public @NotNull Triple<T3, T2, T1> reverse() {
return new Triple<>(val3, val2, val1);
}
@Contract(value = "_ -> new", pure = true)
public @NotNull <T4> Quadruple<T1, T2, T3, T4> concat(@Nullable T4 val4) {
return Quadruple.of(val1, val2, val3, val4);
}
@Contract(value = "_ -> new", pure = true)
public @NotNull <T4> Quadruple<T1, T2, T3, T4> concat(@NotNull Single<T4> val4) {
return Quadruple.of(val1, val2, val3, val4.val());
}
}

31
commons/src/main/java/io/gitlab/jfronny/commons/tuple/Tuple.java
View File

@ -47,6 +47,26 @@ public record Tuple<T1, T2>(@Nullable T1 left, @Nullable T2 right) {
return new Tuple<>(right, left);
}
@Contract(value = "_ -> new", pure = true)
public @NotNull <T3> Triple<T1, T2, T3> concat(@Nullable T3 val3) {
return Triple.of(left, right, val3);
}
@Contract(value = "_, _ -> new", pure = true)
public @NotNull <T3, T4> Quadruple<T1, T2, T3, T4> concat(@Nullable T3 val3, @Nullable T4 val4) {
return Quadruple.of(left, right, val3, val4);
}
@Contract(value = "_ -> new", pure = true)
public @NotNull <T3> Triple<T1, T2, T3> concat(@NotNull Single<T3> val3) {
return Triple.of(left, right, val3.val());
}
@Contract(value = "_ -> new", pure = true)
public @NotNull <T3, T4> Quadruple<T1, T2, T3, T4> concat(@NotNull Tuple<T3, T4> val3) {
return Quadruple.of(left, right, val3.left(), val3.right());
}
@Contract(value = "_ -> new", pure = true)
public static <T1, T2> @NotNull Set<Tuple<T1, T2>> from(@NotNull Map<T1, T2> map) {
Objects.requireNonNull(map);
@ -63,12 +83,11 @@ public record Tuple<T1, T2>(@Nullable T1 left, @Nullable T2 right) {
@Override
public boolean contains(Object o) {
if (o instanceof Tuple tup) {
if (map.containsKey(tup.left) && map.get(tup.left) == tup.right)
if (o instanceof Tuple(var left, var right)) {
if (map.containsKey(left) && map.get(left) == right)
return true;
}
if (map.containsKey(o))
return true;
if (map.containsKey(o)) return true;
return false;
}
@ -89,8 +108,8 @@ public record Tuple<T1, T2>(@Nullable T1 left, @Nullable T2 right) {
@Override
public boolean remove(Object o) {
if (o instanceof Tuple t) {
return map.remove(t.left, t.right);
if (o instanceof Tuple(var left, var right)) {
return map.remove(left, right);
}
return map.remove(o) != null;
}