javaslang.Tuple4 Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of javaslang Show documentation
Show all versions of javaslang Show documentation
Javaslang is a Java standard library extension built for Java 8 and above.
/* / \____ _ _ ____ ______ / \ ____ __ _______
* / / \/ \ / \/ \ / /\__\/ // \/ \ // /\__\ JΛVΛSLΛNG
* _/ / /\ \ \/ / /\ \\__\\ \ // /\ \ /\\/ \ /__\ \ Copyright 2014-2017 Javaslang, http://javaslang.io
* /___/\_/ \_/\____/\_/ \_/\__\/__/\__\_/ \_// \__/\_____/ Licensed under the Apache License, Version 2.0
*/
package javaslang;
/*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*\
G E N E R A T O R C R A F T E D
\*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
import java.io.Serializable;
import java.util.Comparator;
import java.util.Objects;
import java.util.function.Function;
import javaslang.collection.List;
import javaslang.collection.Seq;
/**
* A tuple of 4 elements which can be seen as cartesian product of 4 components.
*
* @param type of the 1st element
* @param type of the 2nd element
* @param type of the 3rd element
* @param type of the 4th element
* @author Daniel Dietrich
* @since 1.1.0
*/
public final class Tuple4 implements Tuple, Comparable>, Serializable {
private static final long serialVersionUID = 1L;
/**
* The 1st element of this tuple.
*/
public final T1 _1;
/**
* The 2nd element of this tuple.
*/
public final T2 _2;
/**
* The 3rd element of this tuple.
*/
public final T3 _3;
/**
* The 4th element of this tuple.
*/
public final T4 _4;
/**
* Constructs a tuple of 4 elements.
*
* @param t1 the 1st element
* @param t2 the 2nd element
* @param t3 the 3rd element
* @param t4 the 4th element
*/
public Tuple4(T1 t1, T2 t2, T3 t3, T4 t4) {
this._1 = t1;
this._2 = t2;
this._3 = t3;
this._4 = t4;
}
public static Comparator> comparator(Comparator t1Comp, Comparator t2Comp, Comparator t3Comp, Comparator t4Comp) {
return (Comparator> & Serializable) (t1, t2) -> {
final int check1 = t1Comp.compare(t1._1, t2._1);
if (check1 != 0) {
return check1;
}
final int check2 = t2Comp.compare(t1._2, t2._2);
if (check2 != 0) {
return check2;
}
final int check3 = t3Comp.compare(t1._3, t2._3);
if (check3 != 0) {
return check3;
}
final int check4 = t4Comp.compare(t1._4, t2._4);
if (check4 != 0) {
return check4;
}
// all components are equal
return 0;
};
}
@SuppressWarnings("unchecked")
private static , U2 extends Comparable, U3 extends Comparable, U4 extends Comparable> int compareTo(Tuple4 o1, Tuple4 o2) {
final Tuple4 t1 = (Tuple4) o1;
final Tuple4 t2 = (Tuple4) o2;
final int check1 = t1._1.compareTo(t2._1);
if (check1 != 0) {
return check1;
}
final int check2 = t1._2.compareTo(t2._2);
if (check2 != 0) {
return check2;
}
final int check3 = t1._3.compareTo(t2._3);
if (check3 != 0) {
return check3;
}
final int check4 = t1._4.compareTo(t2._4);
if (check4 != 0) {
return check4;
}
// all components are equal
return 0;
}
@Override
public int arity() {
return 4;
}
@Override
public int compareTo(Tuple4 that) {
return Tuple4.compareTo(this, that);
}
/**
* Getter of the 1st element of this tuple.
*
* @return the 1st element of this Tuple.
*/
public T1 _1() {
return _1;
}
/**
* Getter of the 2nd element of this tuple.
*
* @return the 2nd element of this Tuple.
*/
public T2 _2() {
return _2;
}
/**
* Getter of the 3rd element of this tuple.
*
* @return the 3rd element of this Tuple.
*/
public T3 _3() {
return _3;
}
/**
* Getter of the 4th element of this tuple.
*
* @return the 4th element of this Tuple.
*/
public T4 _4() {
return _4;
}
/**
* Maps the components of this tuple using a mapper function.
*
* @param mapper the mapper function
* @param new type of the 1st component
* @param new type of the 2nd component
* @param new type of the 3rd component
* @param new type of the 4th component
* @return A new Tuple of same arity.
* @throws NullPointerException if {@code mapper} is null
*/
public Tuple4 map(Function4> mapper) {
Objects.requireNonNull(mapper, "mapper is null");
return mapper.apply(_1, _2, _3, _4);
}
/**
* Maps the components of this tuple using a mapper function for each component.
*
* @param f1 the mapper function of the 1st component
* @param f2 the mapper function of the 2nd component
* @param f3 the mapper function of the 3rd component
* @param f4 the mapper function of the 4th component
* @param new type of the 1st component
* @param new type of the 2nd component
* @param new type of the 3rd component
* @param new type of the 4th component
* @return A new Tuple of same arity.
* @throws NullPointerException if one of the arguments is null
*/
public Tuple4 map(Function f1, Function f2, Function f3, Function f4) {
Objects.requireNonNull(f1, "f1 is null");
Objects.requireNonNull(f2, "f2 is null");
Objects.requireNonNull(f3, "f3 is null");
Objects.requireNonNull(f4, "f4 is null");
return Tuple.of(f1.apply(_1), f2.apply(_2), f3.apply(_3), f4.apply(_4));
}
/**
* Maps the 1st component of this tuple to a new value.
*
* @param new type of the 1st component
* @param mapper A mapping function
* @return a new tuple based on this tuple and substituted 1st component
*/
public Tuple4 map1(Function mapper) {
Objects.requireNonNull(mapper, "mapper is null");
final U u = mapper.apply(_1);
return Tuple.of(u, _2, _3, _4);
}
/**
* Maps the 2nd component of this tuple to a new value.
*
* @param new type of the 2nd component
* @param mapper A mapping function
* @return a new tuple based on this tuple and substituted 2nd component
*/
public Tuple4 map2(Function mapper) {
Objects.requireNonNull(mapper, "mapper is null");
final U u = mapper.apply(_2);
return Tuple.of(_1, u, _3, _4);
}
/**
* Maps the 3rd component of this tuple to a new value.
*
* @param new type of the 3rd component
* @param mapper A mapping function
* @return a new tuple based on this tuple and substituted 3rd component
*/
public Tuple4 map3(Function mapper) {
Objects.requireNonNull(mapper, "mapper is null");
final U u = mapper.apply(_3);
return Tuple.of(_1, _2, u, _4);
}
/**
* Maps the 4th component of this tuple to a new value.
*
* @param new type of the 4th component
* @param mapper A mapping function
* @return a new tuple based on this tuple and substituted 4th component
*/
public Tuple4 map4(Function mapper) {
Objects.requireNonNull(mapper, "mapper is null");
final U u = mapper.apply(_4);
return Tuple.of(_1, _2, _3, u);
}
/**
* Transforms this tuple to an object of type U.
*
* @param f Transformation which creates a new object of type U based on this tuple's contents.
* @param type of the transformation result
* @return An object of type U
* @throws NullPointerException if {@code f} is null
*/
public U transform(Function4 f) {
Objects.requireNonNull(f, "f is null");
return f.apply(_1, _2, _3, _4);
}
@Override
public Seq toSeq() {
return List.of(_1, _2, _3, _4);
}
// -- Object
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
} else if (!(o instanceof Tuple4)) {
return false;
} else {
final Tuple4 that = (Tuple4) o;
return Objects.equals(this._1, that._1)
&& Objects.equals(this._2, that._2)
&& Objects.equals(this._3, that._3)
&& Objects.equals(this._4, that._4);
}
}
@Override
public int hashCode() {
return Objects.hash(_1, _2, _3, _4);
}
@Override
public String toString() {
return String.format("(%s, %s, %s, %s)", _1, _2, _3, _4);
}
}