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
|
/*
* Copyright (C) 2002-2022 Sebastiano Vigna
*
* 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 PACKAGE;
import java.util.Comparator;
/** A type-specific {@link Comparator}; provides methods to compare two primitive types both as objects
* and as primitive types.
*
* <p>Note that {@code fastutil} provides a corresponding abstract class that
* can be used to implement this interface just by specifying the type-specific
* comparator.
*
* @see Comparator
*/
@FunctionalInterface
public interface KEY_COMPARATOR KEY_GENERIC extends Comparator<KEY_GENERIC_CLASS> {
/** Compares its two primitive-type arguments for order. Returns a negative integer,
* zero, or a positive integer as the first argument is less than, equal
* to, or greater than the second.
*
* @see java.util.Comparator
* @return a negative integer, zero, or a positive integer as the first
* argument is less than, equal to, or greater than the second.
*/
int compare(KEY_TYPE k1, KEY_TYPE k2);
@Override
default KEY_COMPARATOR KEY_GENERIC reversed() {
return COMPARATORS.oppositeComparator(this);
}
#if KEYS_PRIMITIVE
/** {@inheritDoc}
* @implSpec This implementation delegates to the corresponding type-specific method.
* @deprecated Please use the corresponding type-specific method instead. */
@Deprecated
@Override
default int compare(KEY_GENERIC_CLASS ok1, KEY_GENERIC_CLASS ok2) {
return compare(ok1.KEY_VALUE(), ok2.KEY_VALUE());
}
/** Return a new comparator that first uses this comparator, then uses the second comparator
* if this comparator compared the two elements as equal.
*
* @see Comparator#thenComparing(Comparator)
*/
default KEY_COMPARATOR KEY_GENERIC thenComparing(KEY_COMPARATOR KEY_SUPER_GENERIC second) {
return (KEY_COMPARATOR KEY_SUPER_GENERIC & java.io.Serializable) (k1, k2) -> {
int comp = compare(k1, k2);
return comp == 0 ? second.compare(k1, k2) : comp;
};
}
@Override
default Comparator<KEY_GENERIC_CLASS> KEY_GENERIC thenComparing(Comparator<? super KEY_GENERIC_CLASS> second) {
if (second instanceof KEY_COMPARATOR) return thenComparing((KEY_COMPARATOR KEY_SUPER_GENERIC)second);
return Comparator.super.thenComparing(second);
}
#endif
}
|
