com.landawn.abacus.util.Triple Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of abacus-android Show documentation
Show all versions of abacus-android Show documentation
A general and simple library for Android
/*
* Copyright (c) 2015, Haiyang Li.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.landawn.abacus.util;
import com.landawn.abacus.annotation.Beta;
import com.landawn.abacus.util.Tuple.Tuple3;
import com.landawn.abacus.util.u.Optional;
import com.landawn.abacus.util.stream.Stream;
/**
*
* @since 0.8
*
* @author Haiyang Li
*
* @param
* @param
* @param
*/
public final class Triple {
public L left;
public M middle;
public R right;
public Triple() {
}
Triple(final L l, final M m, final R r) {
this.left = l;
this.middle = m;
this.right = r;
}
public static Triple of(final L l, final M m, final R r) {
return new Triple<>(l, m, r);
}
/**
*
* @return
*/
public L getLeft() {
return left;
}
public void setLeft(final L left) {
this.left = left;
}
/**
*
* @return
*/
public M getMiddle() {
return middle;
}
public void setMiddle(final M middle) {
this.middle = middle;
}
/**
*
* @return
*/
public R getRight() {
return right;
}
public void setRight(final R right) {
this.right = right;
}
public void set(final L left, final M middle, final R right) {
this.left = left;
this.middle = middle;
this.right = right;
}
public L getAndSetLeft(L newLeft) {
final L res = left;
left = newLeft;
return res;
}
public L setAndGetLeft(L newLeft) {
left = newLeft;
return left;
}
public M getAndSetMiddle(M newMiddle) {
final M res = middle;
middle = newMiddle;
return res;
}
public M setAndGetMiddle(M newMiddle) {
middle = newMiddle;
return middle;
}
public R getAndSetRight(R newRight) {
final R res = newRight;
right = newRight;
return res;
}
public R setAndGetRight(R newRight) {
right = newRight;
return right;
}
/**
* Set to the specified newLeft and returns true
* if predicate returns true. Otherwise returns
* false without setting the value to new value.
*
* @param newLeft
* @param predicate - the first parameter is current pair, the second
* parameter is the newLeft
* @return
*/
public boolean setLeftIf(final L newLeft, Try.BiPredicate, ? super L, E> predicate) throws E {
if (predicate.test(this, newLeft)) {
this.left = newLeft;
return true;
}
return false;
}
/**
* Set to the specified newMiddle and returns true
* if predicate returns true. Otherwise returns
* false without setting the value to new value.
*
* @param newMiddle
* @param predicate - the first parameter is current pair, the second
* parameter is the newMiddle
* @return
*/
public boolean setMiddleIf(final M newMiddle, Try.BiPredicate, ? super M, E> predicate) throws E {
if (predicate.test(this, newMiddle)) {
this.middle = newMiddle;
return true;
}
return false;
}
/**
* Set to the specified newRight and returns true
* if predicate returns true. Otherwise returns
* false without setting the value to new value.
*
* @param newRight
* @param predicate - the first parameter is current pair, the second
* parameter is the newRight
* @return
*/
public boolean setRightIf(final R newRight, Try.BiPredicate, ? super R, E> predicate) throws E {
if (predicate.test(this, newRight)) {
this.right = newRight;
return true;
}
return false;
}
/**
* Set to the specified newLeft and newRight and
* returns true if predicate returns true.
* Otherwise returns false without setting the left/right to
* new values.
*
* @param newLeft
* @param newMiddle
* @param newRight
* @param predicate - the first parameter is current pair, the second
* parameter is the newLeft, the third parameter is the
* newMiddle, the fourth parameter is the
* newRight
* @return
*/
public boolean setIf(final L newLeft, final M newMiddle, final R newRight,
Try.QuadPredicate, ? super L, ? super M, ? super R, E> predicate) throws E {
if (predicate.test(this, newLeft, newMiddle, newRight)) {
this.left = newLeft;
this.middle = newMiddle;
this.right = newRight;
return true;
}
return false;
}
// /**
// * Swap the left and right value. they must be same type.
// */
// public void reverse() {
// Object tmp = left;
// this.left = (L) right;
// this.right = (R) tmp;
// }
/**
* Returns a new instance of Triple<R, M, L>.
*
* @return a new instance of Triple<R, M, L>.
*/
@Beta
public Triple reversed() {
return new Triple<>(this.right, this.middle, this.left);
}
public Triple copy() {
return new Triple<>(this.left, this.middle, this.right);
}
public Object[] toArray() {
return new Object[] { left, middle, right };
}
public A[] toArray(A[] a) {
if (a.length < 3) {
a = N.copyOf(a, 3);
}
a[0] = (A) left;
a[1] = (A) middle;
a[2] = (A) right;
return a;
}
public void forEach(Try.Consumer comsumer) throws E {
final Try.Consumer objComsumer = (Try.Consumer) comsumer;
objComsumer.accept(left);
objComsumer.accept(middle);
objComsumer.accept(right);
}
public void accept(final Try.TriConsumer action) throws E {
action.accept(left, middle, right);
}
public void accept(final Try.Consumer, E> action) throws E {
action.accept(this);
}
public U map(final Try.TriFunction mapper) throws E {
return mapper.apply(left, middle, right);
}
public U map(final Try.Function, U, E> mapper) throws E {
return mapper.apply(this);
}
public Optional> filter(final Try.TriPredicate predicate) throws E {
return predicate.test(left, middle, right) ? Optional.of(this) : Optional.> empty();
}
public Optional> filter(final Try.Predicate, E> predicate) throws E {
return predicate.test(this) ? Optional.of(this) : Optional.> empty();
}
public Stream> stream() {
return Stream.of(this);
}
public Tuple3 toTuple() {
return Tuple.of(left, middle, right);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + N.hashCode(left);
result = prime * result + N.hashCode(middle);
result = prime * result + N.hashCode(right);
return result;
}
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof Triple) {
final Triple other = (Triple) obj;
return N.equals(left, other.left) && N.equals(middle, other.middle) && N.equals(right, other.right);
}
return false;
}
@Override
public String toString() {
return "[" + N.toString(left) + ", " + N.toString(middle) + ", " + N.toString(right) + "]";
}
}