summaryrefslogtreecommitdiff
path: root/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java
blob: 0d2c1b0d894c8189bab9f4461c8c5219279d780d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
package bjc.utils.data;

import java.util.function.BiFunction;
import java.util.function.Function;

/**
 * A pair of values, with nothing special about them.
 * 
 * @author ben
 *
 * @param <LeftType>
 *            The type of the left value
 * @param <RightType>
 *            The type of the right value
 */
public class Pair<LeftType, RightType>
		implements IPair<LeftType, RightType> {
	private LeftType	leftValue;
	private RightType	rightValue;

	/**
	 * Create a new pair with both sides set to null
	 */
	public Pair() {
	}

	/**
	 * Create a new pair with both sides set to the specified values
	 * 
	 * @param left
	 *            The value of the left side
	 * @param right
	 *            The value of the right side
	 */
	public Pair(LeftType left, RightType right) {
		leftValue = left;
		rightValue = right;
	}

	@Override
	public <BoundLeft, BoundRight> IPair<BoundLeft, BoundRight> bind(
			BiFunction<LeftType, RightType, IPair<BoundLeft, BoundRight>> binder) {
		return binder.apply(leftValue, rightValue);
	}

	@Override
	public <BoundLeft> IPair<BoundLeft, RightType> bindLeft(
			Function<LeftType, IPair<BoundLeft, RightType>> leftBinder) {
		return leftBinder.apply(leftValue);
	}

	@Override
	public <BoundRight> IPair<LeftType, BoundRight> bindRight(
			Function<RightType, IPair<LeftType, BoundRight>> rightBinder) {
		return rightBinder.apply(rightValue);
	}

	@Override
	public <MergedType> MergedType
			merge(BiFunction<LeftType, RightType, MergedType> merger) {
		return merger.apply(leftValue, rightValue);
	}

	@Override
	public String toString() {
		return "pair[l=" + leftValue.toString() + ", r="
				+ rightValue.toString() + "]";
	}

	@Override
	public <NewLeft> IPair<NewLeft, RightType>
			mapLeft(Function<LeftType, NewLeft> mapper) {
		return new Pair<>(mapper.apply(leftValue), rightValue);
	}

	@Override
	public <NewRight> IPair<LeftType, NewRight>
			mapRight(Function<RightType, NewRight> mapper) {
		return new Pair<>(leftValue, mapper.apply(rightValue));
	}
}