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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
/*
* Copyright (C) 2002-2024 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;
import java.util.Objects;
import java.io.Serializable;
/** 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
#define CONCAT_(A, B) A ## B
#define CONCAT(A, B) CONCAT_(A, B)
#define KEY_TO_OBJ_FUNCTION CONCAT(KEY_TYPE_CAP, 2ObjectFunction)
#define KEY_TO_INT_FUNCTION CONCAT(KEY_TYPE_CAP, 2IntFunction)
#define KEY_TO_LONG_FUNCTION CONCAT(KEY_TYPE_CAP, 2LongFunction)
#define KEY_TO_DOUBLE_FUNCTION CONCAT(KEY_TYPE_CAP, 2DoubleFunction)
/**
* Accepts a function that extracts a {@link java.lang.Comparable Comparable} sort key from
* a primitive key, and returns a comparator that compares by that sort key.
*
* <p>
* The returned comparator is serializable if the specified function is also serializable.
*
* @param keyExtractor the function used to extract the {@link Comparable} sort key
* @return a comparator that compares by an extracted key
* @throws NullPointerException if {@code keyExtractor} is {@code null}
*/
#if KEYS_PRIMITIVE
static <U extends Comparable<? super U>> KEY_COMPARATOR KEY_GENERIC comparing(KEY_TO_OBJ_FUNCTION <? extends U> keyExtractor) {
#else
static <K, U extends Comparable<? super U>> KEY_COMPARATOR KEY_GENERIC comparing(KEY_TO_OBJ_FUNCTION <? super K, ? extends U> keyExtractor) {
#endif
Objects.requireNonNull(keyExtractor);
return (KEY_COMPARATOR KEY_GENERIC & Serializable)
(k1, k2) -> keyExtractor.get(k1).compareTo(keyExtractor.get(k2));
}
/**
* Accepts a function that extracts a sort key from a primitive key, and returns a
* comparator that compares by that sort key using the specified {@link Comparator}.
*
* <p>
* The returned comparator is serializable if the specified function and comparator are
* both serializable.
*
* @param keyExtractor the function used to extract the sort key
* @param keyComparator the {@code Comparator} used to compare the sort key
* @return a comparator that compares by an extracted key using the specified {@code Comparator}
* @throws NullPointerException if {@code keyExtractor} or {@code keyComparator} are {@code null}
*/
#if KEYS_PRIMITIVE
static <U extends Comparable<? super U>> KEY_COMPARATOR KEY_GENERIC comparing(KEY_TO_OBJ_FUNCTION <? extends U> keyExtractor, Comparator<? super U> keyComparator) {
#else
static <K, U extends Comparable<? super U>> KEY_COMPARATOR KEY_GENERIC comparing(KEY_TO_OBJ_FUNCTION <? super K, ? extends U> keyExtractor, Comparator<? super U> keyComparator) {
#endif
Objects.requireNonNull(keyExtractor);
Objects.requireNonNull(keyComparator);
return (KEY_COMPARATOR KEY_GENERIC & Serializable)
(k1, k2) -> keyComparator.compare(keyExtractor.get(k1), keyExtractor.get(k2));
}
/**
* Accepts a function that extracts an {@code int} sort key from a primitive key,
* and returns a comparator that compares by that sort key.
*
* <p>
* The returned comparator is serializable if the specified function
* is also serializable.
*
* @param keyExtractor the function used to extract the integer sort key
* @return a comparator that compares by an extracted key
* @throws NullPointerException if {@code keyExtractor} is {@code null}
*/
static KEY_GENERIC KEY_COMPARATOR KEY_GENERIC comparingInt(KEY_TO_INT_FUNCTION KEY_SUPER_GENERIC keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (KEY_COMPARATOR KEY_GENERIC & Serializable)
(k1, k2) -> Integer.compare(keyExtractor.get(k1), keyExtractor.get(k2));
}
/**
* Accepts a function that extracts an {@code long} sort key from a primitive key,
* and returns a comparator that compares by that sort key.
*
* <p>
* The returned comparator is serializable if the specified function
* is also serializable.
*
* @param keyExtractor the function used to extract the long sort key
* @return a comparator that compares by an extracted key
* @throws NullPointerException if {@code keyExtractor} is {@code null}
*/
static KEY_GENERIC KEY_COMPARATOR KEY_GENERIC comparingLong(KEY_TO_LONG_FUNCTION KEY_SUPER_GENERIC keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (KEY_COMPARATOR KEY_GENERIC & Serializable)
(k1, k2) -> Long.compare(keyExtractor.get(k1), keyExtractor.get(k2));
}
/**
* Accepts a function that extracts an {@code double} sort key from a primitive key,
* and returns a comparator that compares by that sort key.
*
* <p>
* The returned comparator is serializable if the specified function
* is also serializable.
*
* @param keyExtractor the function used to extract the double sort key
* @return a comparator that compares by an extracted key
* @throws NullPointerException if {@code keyExtractor} is {@code null}
*/
static KEY_GENERIC KEY_COMPARATOR KEY_GENERIC comparingDouble(KEY_TO_DOUBLE_FUNCTION KEY_SUPER_GENERIC keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (KEY_COMPARATOR KEY_GENERIC & Serializable)
(k1, k2) -> Double.compare(keyExtractor.get(k1), keyExtractor.get(k2));
}
}
|
