/
ToChar.java
111 lines (97 loc) · 3.02 KB
/
ToChar.java
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package com.speedment.runtime.compute;
import com.speedment.common.function.CharUnaryOperator;
import com.speedment.common.function.ToCharFunction;
import com.speedment.runtime.compute.expression.Expression;
import com.speedment.runtime.compute.expression.ExpressionType;
import com.speedment.runtime.compute.internal.expression.CastUtil;
import com.speedment.runtime.compute.internal.expression.ComposedUtil;
import com.speedment.runtime.compute.internal.expression.MapperUtil;
import com.speedment.runtime.compute.trait.*;
import static java.util.Objects.requireNonNull;
import java.util.function.Function;
/**
* Expression that given an entity returns a {@code char} value. This expression
* can be implemented using a lambda, or it can be a result of another
* operation. It has additional methods for operating on it.
*
* @param <T> type to extract from
*
* @see ToCharFunction
*
* @author Emil Forslund
* @since 3.1.0
*/
@FunctionalInterface
public interface ToChar<T>
extends Expression<T>,
ToCharFunction<T>,
HasAsDouble<T>,
HasAsInt<T>,
HasAsLong<T>,
HasMap<T, CharUnaryOperator, ToChar<T>>,
HasCase<T, ToChar<T>>,
HasHash<T>,
HasCompare<T>,
HasCompose<T> {
/**
* Returns a typed {@code ToChar<T>} using the provided {@code lambda}.
*
* @param <T> type to extract from
* @param lambda to convert
* @return a typed {@code ToChar<T>} using the provided {@code lambda}
*
* @throws NullPointerException if the provided {@code lambda} is
* {@code null}
*/
static <T> ToChar<T> of(ToCharFunction<T> lambda) {
if (lambda instanceof ToChar) {
return (ToChar<T>) lambda;
} else {
return lambda::applyAsChar;
}
}
@Override
default ExpressionType expressionType() {
return ExpressionType.CHAR;
}
@Override
default ToDouble<T> asDouble() {
return CastUtil.castCharToDouble(this);
}
@Override
default ToInt<T> asInt() {
return CastUtil.castCharToInt(this);
}
@Override
default ToLong<T> asLong() {
return CastUtil.castCharToLong(this);
}
@Override
default ToChar<T> map(CharUnaryOperator operator) {
return MapperUtil.mapChar(this, operator);
}
@Override
default ToChar<T> toUpperCase() {
return map(Character::toUpperCase);
}
@Override
default ToChar<T> toLowerCase() {
return map(Character::toLowerCase);
}
@Override
default long hash(T object) {
return applyAsChar(object);
}
@Override
default int compare(T first, T second) {
final char f = applyAsChar(first);
final char s = applyAsChar(second);
return Character.compare(f, s);
}
@Override
default <V> ToChar<V> compose(Function<? super V, ? extends T> before) {
@SuppressWarnings("unchecked")
final Function<V, T> casted = (Function<V, T>) before;
return ComposedUtil.composeToChar(casted, this);
}
}