1 | // License: GPL. For details, see LICENSE file.
|
---|
2 | package org.openstreetmap.josm.gui.mappaint.mapcss;
|
---|
3 |
|
---|
4 | import java.awt.Color;
|
---|
5 | import java.lang.annotation.ElementType;
|
---|
6 | import java.lang.annotation.Retention;
|
---|
7 | import java.lang.annotation.RetentionPolicy;
|
---|
8 | import java.lang.annotation.Target;
|
---|
9 | import java.lang.reflect.Array;
|
---|
10 | import java.util.Arrays;
|
---|
11 | import java.util.Collection;
|
---|
12 | import java.util.Collections;
|
---|
13 | import java.util.HashMap;
|
---|
14 | import java.util.List;
|
---|
15 | import java.util.Map;
|
---|
16 | import java.util.Objects;
|
---|
17 | import java.util.function.BiFunction;
|
---|
18 | import java.util.function.DoubleBinaryOperator;
|
---|
19 | import java.util.function.DoubleUnaryOperator;
|
---|
20 | import java.util.function.Function;
|
---|
21 |
|
---|
22 | import org.openstreetmap.josm.data.osm.PrimitiveId;
|
---|
23 | import org.openstreetmap.josm.gui.mappaint.Cascade;
|
---|
24 | import org.openstreetmap.josm.gui.mappaint.Environment;
|
---|
25 | import org.openstreetmap.josm.tools.SubclassFilteredCollection;
|
---|
26 | import org.openstreetmap.josm.tools.Utils;
|
---|
27 |
|
---|
28 | /**
|
---|
29 | * Factory to generate {@link Expression}s.
|
---|
30 | * <p>
|
---|
31 | * See {@link #createFunctionExpression}.
|
---|
32 | */
|
---|
33 | public final class ExpressionFactory {
|
---|
34 |
|
---|
35 | /**
|
---|
36 | * Marks functions which should be executed also when one or more arguments are null.
|
---|
37 | */
|
---|
38 | @Target(ElementType.METHOD)
|
---|
39 | @Retention(RetentionPolicy.RUNTIME)
|
---|
40 | @interface NullableArguments {}
|
---|
41 |
|
---|
42 | /**
|
---|
43 | * Represents a function that accepts three arguments and produces a result. This is a specialization of {@link Function}.
|
---|
44 | * This is a functional interface whose functional method is {@link #apply(Object, Object, Object)}.
|
---|
45 | * @param <T> The type of the first argument
|
---|
46 | * @param <U> The type of the second argument
|
---|
47 | * @param <V> The type of the third argument
|
---|
48 | * @param <R> The type of the result of the function
|
---|
49 | * @see Function
|
---|
50 | * @see BiFunction
|
---|
51 | */
|
---|
52 | @FunctionalInterface
|
---|
53 | public interface TriFunction<T, U, V, R> {
|
---|
54 | /**
|
---|
55 | * Call the function
|
---|
56 | * @param t The first argument
|
---|
57 | * @param u The second argument
|
---|
58 | * @param v The third argument
|
---|
59 | * @return The result of the function call
|
---|
60 | */
|
---|
61 | R apply(T t, U u, V v);
|
---|
62 | }
|
---|
63 |
|
---|
64 | /**
|
---|
65 | * Represents a function that accepts four arguments and produces a result. This is a specialization of {@link Function}.
|
---|
66 | * This is a functional interface whose functional method is {@link #apply(Object, Object, Object, Object)}.
|
---|
67 | * @param <T> The type of the first argument
|
---|
68 | * @param <U> The type of the second argument
|
---|
69 | * @param <V> The type of the third argument
|
---|
70 | * @param <W> The type of the fourth argument
|
---|
71 | * @param <R> The type of the result of the function
|
---|
72 | * @see Function
|
---|
73 | * @see BiFunction
|
---|
74 | */
|
---|
75 | @FunctionalInterface
|
---|
76 | public interface QuadFunction<T, U, V, W, R> {
|
---|
77 | /**
|
---|
78 | * Call the function
|
---|
79 | * @param t The first argument
|
---|
80 | * @param u The second argument
|
---|
81 | * @param v The third argument
|
---|
82 | * @param w The fourth argument
|
---|
83 | * @return The result of the function call
|
---|
84 | */
|
---|
85 | R apply(T t, U u, V v, W w);
|
---|
86 | }
|
---|
87 |
|
---|
88 | @FunctionalInterface
|
---|
89 | interface Factory {
|
---|
90 | Expression createExpression(List<Expression> args);
|
---|
91 |
|
---|
92 | static Factory of(DoubleUnaryOperator operator) {
|
---|
93 | return of(Double.class, operator::applyAsDouble);
|
---|
94 | }
|
---|
95 |
|
---|
96 | static Factory ofNumberVarArgs(double identity, DoubleUnaryOperator unaryOperator, DoubleBinaryOperator operator) {
|
---|
97 | return args -> env -> {
|
---|
98 | if (args.isEmpty()) {
|
---|
99 | return identity;
|
---|
100 | } else if (args.size() == 1) {
|
---|
101 | Double arg = Cascade.convertTo(args.get(0).evaluate(env), Double.class);
|
---|
102 | return arg == null ? null : unaryOperator.applyAsDouble(arg);
|
---|
103 | } else {
|
---|
104 | return args.stream()
|
---|
105 | .map(arg -> Cascade.convertTo(arg.evaluate(env), Double.class))
|
---|
106 | .filter(Objects::nonNull)
|
---|
107 | .reduce(operator::applyAsDouble).orElse(null);
|
---|
108 | }
|
---|
109 | };
|
---|
110 | }
|
---|
111 |
|
---|
112 | static Factory ofStringVarargs(BiFunction<Environment, String[], ?> function) {
|
---|
113 | return args -> env -> function.apply(env, args.stream()
|
---|
114 | .map(arg -> Cascade.convertTo(arg.evaluate(env), String.class))
|
---|
115 | .toArray(String[]::new));
|
---|
116 | }
|
---|
117 |
|
---|
118 | static Factory ofObjectVarargs(BiFunction<Environment, Object[], ?> function) {
|
---|
119 | return args -> env -> function.apply(env, args.stream()
|
---|
120 | .map(arg -> arg.evaluate(env))
|
---|
121 | .toArray(Object[]::new));
|
---|
122 | }
|
---|
123 |
|
---|
124 | static <T> Factory of(Class<T> type, Function<T, ?> function) {
|
---|
125 | return args -> env -> {
|
---|
126 | T v = Cascade.convertTo(args.get(0).evaluate(env), type);
|
---|
127 | return v == null ? null : function.apply(v);
|
---|
128 | };
|
---|
129 | }
|
---|
130 |
|
---|
131 | static <T, U> Factory of(Class<T> type1, Class<U> type2, BiFunction<T, U, ?> function) {
|
---|
132 | return args -> env -> {
|
---|
133 | T v1 = Cascade.convertTo(args.get(0).evaluate(env), type1);
|
---|
134 | U v2 = Cascade.convertTo(args.get(1).evaluate(env), type2);
|
---|
135 | return v1 == null || v2 == null ? null : function.apply(v1, v2);
|
---|
136 | };
|
---|
137 | }
|
---|
138 |
|
---|
139 | static <T, U, V> Factory of(Class<T> type1, Class<U> type2, Class<V> type3,
|
---|
140 | BiFunction<T, U, ?> biFunction, TriFunction<T, U, V, ?> triFunction) {
|
---|
141 | return args -> env -> {
|
---|
142 | T v1 = !args.isEmpty() ? Cascade.convertTo(args.get(0).evaluate(env), type1) : null;
|
---|
143 | U v2 = args.size() >= 2 ? Cascade.convertTo(args.get(1).evaluate(env), type2) : null;
|
---|
144 | V v3 = args.size() >= 3 ? Cascade.convertTo(args.get(2).evaluate(env), type3) : null;
|
---|
145 | return v1 == null || v2 == null ? null : v3 == null ? biFunction.apply(v1, v2) : triFunction.apply(v1, v2, v3);
|
---|
146 | };
|
---|
147 | }
|
---|
148 |
|
---|
149 | static <T, U, V, W> Factory of(Class<T> type1, Class<U> type2, Class<V> type3, Class<W> type4,
|
---|
150 | QuadFunction<T, U, V, W, ?> function) {
|
---|
151 | return args -> env -> {
|
---|
152 | T v1 = !args.isEmpty() ? Cascade.convertTo(args.get(0).evaluate(env), type1) : null;
|
---|
153 | U v2 = args.size() >= 2 ? Cascade.convertTo(args.get(1).evaluate(env), type2) : null;
|
---|
154 | V v3 = args.size() >= 3 ? Cascade.convertTo(args.get(2).evaluate(env), type3) : null;
|
---|
155 | W v4 = args.size() >= 4 ? Cascade.convertTo(args.get(3).evaluate(env), type4) : null;
|
---|
156 | return v1 == null || v2 == null || v3 == null || v4 == null ? null : function.apply(v1, v2, v3, v4);
|
---|
157 | };
|
---|
158 | }
|
---|
159 |
|
---|
160 | /**
|
---|
161 | * Create a factory that accepts an iterable (array <i>or</i> generic iterable)
|
---|
162 | * @param type The expected type class
|
---|
163 | * @param function The function to apply the arguments to
|
---|
164 | * @param <T> The iterable type
|
---|
165 | * @return The result of the function call
|
---|
166 | */
|
---|
167 | @SuppressWarnings("unchecked")
|
---|
168 | static <T> Factory ofIterable(Class<T> type, Function<Iterable<T>, ?> function) {
|
---|
169 | return args -> env -> {
|
---|
170 | Object arg0 = args.get(0).evaluate(env);
|
---|
171 | if (args.size() == 1 && arg0 instanceof Iterable) {
|
---|
172 | return function.apply((Iterable<T>) arg0);
|
---|
173 | } else {
|
---|
174 | return function.apply(Arrays.asList(args.stream().map(arg -> Cascade.convertTo(arg, type))
|
---|
175 | .toArray(length -> (T[]) Array.newInstance(type, length))));
|
---|
176 | }
|
---|
177 | };
|
---|
178 | }
|
---|
179 |
|
---|
180 | /**
|
---|
181 | * Create a {@link Factory} for a function
|
---|
182 | * @param function The function to use
|
---|
183 | * @return The result of the function
|
---|
184 | */
|
---|
185 | static Factory ofEnv(Function<Environment, ?> function) {
|
---|
186 | return args -> function::apply;
|
---|
187 | }
|
---|
188 |
|
---|
189 | /**
|
---|
190 | * Create a {@link Factory} for a function that takes a parameter
|
---|
191 | * @param type The parameter type class
|
---|
192 | * @param function The function to use when one argument is available
|
---|
193 | * @param <T> the type of the input to the function
|
---|
194 | * @return The result of the function
|
---|
195 | */
|
---|
196 | static <T> Factory ofEnv(Class<T> type, BiFunction<Environment, T, ?> function) {
|
---|
197 | return args -> env -> {
|
---|
198 | T v = Cascade.convertTo(args.get(0).evaluate(env), type);
|
---|
199 | return v == null ? null : function.apply(env, v);
|
---|
200 | };
|
---|
201 | }
|
---|
202 |
|
---|
203 | /**
|
---|
204 | * Create a {@link Factory} for an overloaded function
|
---|
205 | * @param type1 The first parameter type class
|
---|
206 | * @param type2 The second parameter type class
|
---|
207 | * @param biFunction The function to use when one argument is available
|
---|
208 | * @param triFunction The function to use when two arguments are available
|
---|
209 | * @param <T> the type of the input to the function
|
---|
210 | * @param <U> the type of the input to the function
|
---|
211 | * @return The result of one of the functions
|
---|
212 | */
|
---|
213 | static <T, U> Factory ofEnv(Class<T> type1, Class<U> type2,
|
---|
214 | BiFunction<Environment, T, ?> biFunction, TriFunction<Environment, T, U, ?> triFunction) {
|
---|
215 | return args -> env -> {
|
---|
216 | T v1 = !args.isEmpty() ? Cascade.convertTo(args.get(0).evaluate(env), type1) : null;
|
---|
217 | U v2 = args.size() >= 2 ? Cascade.convertTo(args.get(1).evaluate(env), type2) : null;
|
---|
218 | return v1 == null ? null : v2 == null ? biFunction.apply(env, v1) : triFunction.apply(env, v1, v2);
|
---|
219 | };
|
---|
220 | }
|
---|
221 |
|
---|
222 | /**
|
---|
223 | * Create a {@link Factory} for an overloaded function
|
---|
224 | * @param type1 The first parameter type class
|
---|
225 | * @param type2 The second parameter type class
|
---|
226 | * @param function The function to use when no args are available
|
---|
227 | * @param biFunction The function to use when one argument is available
|
---|
228 | * @param triFunction The function to use when two arguments are available
|
---|
229 | * @param <T> the type of the input to the function
|
---|
230 | * @param <U> the type of the input to the function
|
---|
231 | * @return The result of one of the functions
|
---|
232 | */
|
---|
233 | static <T, U> Factory ofEnv(Class<T> type1, Class<U> type2, Function<Environment, ?> function,
|
---|
234 | BiFunction<Environment, T, ?> biFunction, TriFunction<Environment, T, U, ?> triFunction) {
|
---|
235 | return args -> env -> {
|
---|
236 | T v1 = !args.isEmpty() ? Cascade.convertTo(args.get(0).evaluate(env), type1) : null;
|
---|
237 | U v2 = args.size() >= 2 ? Cascade.convertTo(args.get(1).evaluate(env), type2) : null;
|
---|
238 | return v1 == null ? function.apply(env) : v2 == null ? biFunction.apply(env, v1) : triFunction.apply(env, v1, v2);
|
---|
239 | };
|
---|
240 | }
|
---|
241 | }
|
---|
242 |
|
---|
243 | static final Map<String, Factory> FACTORY_MAP = new HashMap<>();
|
---|
244 |
|
---|
245 | static {
|
---|
246 | initFactories();
|
---|
247 | }
|
---|
248 |
|
---|
249 | @SuppressWarnings("unchecked")
|
---|
250 | private static void initFactories() {
|
---|
251 | FACTORY_MAP.put("CRC32_checksum", Factory.of(String.class, Functions::CRC32_checksum));
|
---|
252 | FACTORY_MAP.put("JOSM_pref", Factory.ofEnv(String.class, String.class, null, Functions::JOSM_pref));
|
---|
253 | FACTORY_MAP.put("JOSM_search", Factory.ofEnv(String.class, Functions::JOSM_search));
|
---|
254 | FACTORY_MAP.put("URL_decode", Factory.of(String.class, Functions::URL_decode));
|
---|
255 | FACTORY_MAP.put("URL_encode", Factory.of(String.class, Functions::URL_encode));
|
---|
256 | FACTORY_MAP.put("XML_encode", Factory.of(String.class, Functions::XML_encode));
|
---|
257 | FACTORY_MAP.put("abs", Factory.of(Math::acos));
|
---|
258 | FACTORY_MAP.put("acos", Factory.of(Math::acos));
|
---|
259 | FACTORY_MAP.put("alpha", Factory.of(Color.class, Functions::alpha));
|
---|
260 | FACTORY_MAP.put("any", Factory.ofObjectVarargs(Functions::any));
|
---|
261 | FACTORY_MAP.put("areasize", Factory.ofEnv(Functions::areasize));
|
---|
262 | FACTORY_MAP.put("asin", Factory.of(Math::asin));
|
---|
263 | FACTORY_MAP.put("at", Factory.ofEnv(double.class, double.class, null, Functions::at));
|
---|
264 | FACTORY_MAP.put("atan", Factory.of(Math::atan));
|
---|
265 | FACTORY_MAP.put("atan2", Factory.of(Double.class, Double.class, Math::atan2));
|
---|
266 | FACTORY_MAP.put("blue", Factory.of(Color.class, Functions::blue));
|
---|
267 | FACTORY_MAP.put("cardinal_to_radians", Factory.of(String.class, Functions::cardinal_to_radians));
|
---|
268 | FACTORY_MAP.put("ceil", Factory.of(Math::ceil));
|
---|
269 | FACTORY_MAP.put("center", Factory.ofEnv(Functions::center));
|
---|
270 | FACTORY_MAP.put("child_tag", Factory.ofEnv(String.class, Functions::child_tag));
|
---|
271 | FACTORY_MAP.put("color2html", Factory.of(Color.class, Functions::color2html));
|
---|
272 | FACTORY_MAP.put("concat", Factory.ofObjectVarargs(Functions::concat));
|
---|
273 | FACTORY_MAP.put("convert_primitive_to_string", Factory.of(PrimitiveId.class, Functions::convert_primitive_to_string));
|
---|
274 | FACTORY_MAP.put("convert_primitives_to_string", Factory.ofIterable(PrimitiveId.class, Functions::convert_primitives_to_string));
|
---|
275 | FACTORY_MAP.put("cos", Factory.of(Math::cos));
|
---|
276 | FACTORY_MAP.put("cosh", Factory.of(Math::cosh));
|
---|
277 | FACTORY_MAP.put("count", Factory.of(List.class, Functions::count));
|
---|
278 | FACTORY_MAP.put("count_roles", Factory.ofStringVarargs(Functions::count_roles));
|
---|
279 | FACTORY_MAP.put("degree_to_radians", Factory.of(Functions::degree_to_radians));
|
---|
280 | FACTORY_MAP.put("divided_by", Factory.ofNumberVarArgs(1.0, DoubleUnaryOperator.identity(), Functions::divided_by));
|
---|
281 | FACTORY_MAP.put("equal", Factory.of(Object.class, Object.class, Functions::equal));
|
---|
282 | FACTORY_MAP.put("eval", Factory.of(Object.class, Functions::eval));
|
---|
283 | FACTORY_MAP.put("exp", Factory.of(Math::exp));
|
---|
284 | FACTORY_MAP.put("floor", Factory.of(Math::floor));
|
---|
285 | FACTORY_MAP.put("get", Factory.of(List.class, float.class, Functions::get));
|
---|
286 | FACTORY_MAP.put("gpx_distance", Factory.ofEnv(Functions::gpx_distance));
|
---|
287 | FACTORY_MAP.put("greater", Factory.of(float.class, float.class, Functions::greater));
|
---|
288 | FACTORY_MAP.put("greater_equal", Factory.of(float.class, float.class, Functions::greater_equal));
|
---|
289 | FACTORY_MAP.put("green", Factory.of(Color.class, Functions::green));
|
---|
290 | FACTORY_MAP.put("has_tag_key", Factory.ofEnv(String.class, Functions::has_tag_key));
|
---|
291 | FACTORY_MAP.put("hsb_color", Factory.of(float.class, float.class, float.class, null, Functions::hsb_color));
|
---|
292 | FACTORY_MAP.put("html2color", Factory.of(String.class, Functions::html2color));
|
---|
293 | FACTORY_MAP.put("index", Factory.ofEnv(Functions::index));
|
---|
294 | FACTORY_MAP.put("inside", Factory.ofEnv(String.class, Functions::inside));
|
---|
295 | FACTORY_MAP.put("is_anticlockwise", Factory.ofEnv(Functions::is_anticlockwise));
|
---|
296 | FACTORY_MAP.put("is_clockwise", Factory.ofEnv(Functions::is_clockwise));
|
---|
297 | FACTORY_MAP.put("is_prop_set", Factory.ofEnv(String.class, String.class, Functions::is_prop_set, Functions::is_prop_set));
|
---|
298 | FACTORY_MAP.put("is_right_hand_traffic", Factory.ofEnv(Functions::is_right_hand_traffic));
|
---|
299 | FACTORY_MAP.put("is_similar", Factory.of(String.class, String.class, Functions::is_similar));
|
---|
300 | FACTORY_MAP.put("join", Factory.ofStringVarargs(Functions::join));
|
---|
301 | FACTORY_MAP.put("join_list", Factory.of(String.class, List.class, Functions::join_list));
|
---|
302 | FACTORY_MAP.put("less", Factory.of(float.class, float.class, Functions::less));
|
---|
303 | FACTORY_MAP.put("less_equal", Factory.of(float.class, float.class, Functions::less_equal));
|
---|
304 | FACTORY_MAP.put("list", Factory.ofObjectVarargs(Functions::list));
|
---|
305 | FACTORY_MAP.put("log", Factory.of(Math::log));
|
---|
306 | FACTORY_MAP.put("lower", Factory.of(String.class, Functions::lower));
|
---|
307 | FACTORY_MAP.put("minus", Factory.ofNumberVarArgs(0.0, v -> -v, Functions::minus));
|
---|
308 | FACTORY_MAP.put("mod", Factory.of(float.class, float.class, Functions::mod));
|
---|
309 | FACTORY_MAP.put("not", Factory.of(boolean.class, Functions::not));
|
---|
310 | FACTORY_MAP.put("not_equal", Factory.of(Object.class, Object.class, Functions::not_equal));
|
---|
311 | FACTORY_MAP.put("number_of_tags", Factory.ofEnv(Functions::number_of_tags));
|
---|
312 | FACTORY_MAP.put("osm_changeset_id", Factory.ofEnv(Functions::osm_changeset_id));
|
---|
313 | FACTORY_MAP.put("osm_id", Factory.ofEnv(Functions::osm_id));
|
---|
314 | FACTORY_MAP.put("osm_timestamp", Factory.ofEnv(Functions::osm_timestamp));
|
---|
315 | FACTORY_MAP.put("osm_user_id", Factory.ofEnv(Functions::osm_user_id));
|
---|
316 | FACTORY_MAP.put("osm_user_name", Factory.ofEnv(Functions::osm_user_name));
|
---|
317 | FACTORY_MAP.put("osm_version", Factory.ofEnv(Functions::osm_version));
|
---|
318 | FACTORY_MAP.put("outside", Factory.ofEnv(String.class, Functions::outside));
|
---|
319 | FACTORY_MAP.put("parent_osm_id", Factory.ofEnv(Functions::parent_osm_id));
|
---|
320 | FACTORY_MAP.put("parent_osm_primitives", Factory.ofEnv(String.class, String.class,
|
---|
321 | Functions::parent_osm_primitives, Functions::parent_osm_primitives, Functions::parent_osm_primitives));
|
---|
322 | FACTORY_MAP.put("parent_tag", Factory.ofEnv(String.class, Functions::parent_tag));
|
---|
323 | FACTORY_MAP.put("parent_tags", Factory.ofEnv(String.class, Functions::parent_tags));
|
---|
324 | FACTORY_MAP.put("parent_way_angle", Factory.ofEnv(Functions::parent_way_angle));
|
---|
325 | FACTORY_MAP.put("plus", Factory.ofNumberVarArgs(0.0, DoubleUnaryOperator.identity(), Functions::plus));
|
---|
326 | FACTORY_MAP.put("print", Factory.of(Object.class, Functions::print));
|
---|
327 | FACTORY_MAP.put("println", Factory.of(Object.class, Functions::println));
|
---|
328 | FACTORY_MAP.put("prop", Factory.ofEnv(String.class, String.class, Functions::prop, Functions::prop));
|
---|
329 | FACTORY_MAP.put("red", Factory.of(Color.class, Functions::red));
|
---|
330 | FACTORY_MAP.put("regexp_match", Factory.of(String.class, String.class, String.class, Functions::regexp_match, Functions::regexp_match));
|
---|
331 | FACTORY_MAP.put("regexp_test", Factory.of(String.class, String.class, String.class, Functions::regexp_test, Functions::regexp_test));
|
---|
332 | FACTORY_MAP.put("replace", Factory.of(String.class, String.class, String.class, null, Functions::replace));
|
---|
333 | FACTORY_MAP.put("rgb", Factory.of(float.class, float.class, float.class, null, Functions::rgb));
|
---|
334 | FACTORY_MAP.put("rgba", Factory.of(float.class, float.class, float.class, float.class, Functions::rgba));
|
---|
335 | FACTORY_MAP.put("role", Factory.ofEnv(Functions::role));
|
---|
336 | FACTORY_MAP.put("round", Factory.of(Math::round));
|
---|
337 | FACTORY_MAP.put("setting", Factory.ofEnv(String.class, Functions::setting));
|
---|
338 | FACTORY_MAP.put("signum", Factory.of(Math::signum));
|
---|
339 | FACTORY_MAP.put("sin", Factory.of(Math::sin));
|
---|
340 | FACTORY_MAP.put("sinh", Factory.of(Math::sinh));
|
---|
341 | FACTORY_MAP.put("sort", Factory.ofStringVarargs(Functions::sort));
|
---|
342 | FACTORY_MAP.put("sort_list", Factory.of(List.class, Functions::sort_list));
|
---|
343 | FACTORY_MAP.put("split", Factory.of(String.class, String.class, Functions::split));
|
---|
344 | FACTORY_MAP.put("sqrt", Factory.of(Math::sqrt));
|
---|
345 | FACTORY_MAP.put("substring", Factory.of(String.class, float.class, float.class, Functions::substring, Functions::substring));
|
---|
346 | FACTORY_MAP.put("tag", Factory.ofEnv(String.class, Functions::tag));
|
---|
347 | FACTORY_MAP.put("tag_regex", Factory.ofEnv(String.class, String.class, Functions::tag_regex, Functions::tag_regex));
|
---|
348 | FACTORY_MAP.put("tan", Factory.of(Math::tan));
|
---|
349 | FACTORY_MAP.put("tanh", Factory.of(Math::tanh));
|
---|
350 | FACTORY_MAP.put("times", Factory.ofNumberVarArgs(1.0, DoubleUnaryOperator.identity(), Functions::times));
|
---|
351 | FACTORY_MAP.put("title", Factory.of(String.class, Functions::title));
|
---|
352 | FACTORY_MAP.put("to_boolean", Factory.of(String.class, Functions::to_boolean));
|
---|
353 | FACTORY_MAP.put("to_byte", Factory.of(String.class, Functions::to_byte));
|
---|
354 | FACTORY_MAP.put("to_double", Factory.of(String.class, Functions::to_double));
|
---|
355 | FACTORY_MAP.put("to_float", Factory.of(String.class, Functions::to_float));
|
---|
356 | FACTORY_MAP.put("to_int", Factory.of(String.class, Functions::to_int));
|
---|
357 | FACTORY_MAP.put("to_long", Factory.of(String.class, Functions::to_long));
|
---|
358 | FACTORY_MAP.put("to_short", Factory.of(String.class, Functions::to_short));
|
---|
359 | FACTORY_MAP.put("tr", Factory.ofStringVarargs(Functions::tr));
|
---|
360 | FACTORY_MAP.put("trim", Factory.of(String.class, Functions::trim));
|
---|
361 | FACTORY_MAP.put("trim_list", Factory.of(List.class, Functions::trim_list));
|
---|
362 | FACTORY_MAP.put("uniq", Factory.ofStringVarargs(Functions::uniq));
|
---|
363 | FACTORY_MAP.put("uniq_list", Factory.of(List.class, Functions::uniq_list));
|
---|
364 | FACTORY_MAP.put("upper", Factory.of(String.class, Functions::upper));
|
---|
365 | FACTORY_MAP.put("waylength", Factory.ofEnv(Functions::waylength));
|
---|
366 | }
|
---|
367 |
|
---|
368 | private ExpressionFactory() {
|
---|
369 | // Hide default constructor for utils classes
|
---|
370 | }
|
---|
371 |
|
---|
372 | /**
|
---|
373 | * Main method to create an function-like expression.
|
---|
374 | *
|
---|
375 | * @param name the name of the function or operator
|
---|
376 | * @param args the list of arguments (as expressions)
|
---|
377 | * @return the generated Expression. If no suitable function can be found,
|
---|
378 | * returns {@link NullExpression#INSTANCE}.
|
---|
379 | */
|
---|
380 | public static Expression createFunctionExpression(String name, List<Expression> args) {
|
---|
381 | if ("cond".equals(name) && args.size() == 3)
|
---|
382 | return new CondOperator(args.get(0), args.get(1), args.get(2));
|
---|
383 | else if ("and".equals(name))
|
---|
384 | return new AndOperator(args);
|
---|
385 | else if ("or".equals(name))
|
---|
386 | return new OrOperator(args);
|
---|
387 | else if ("length".equals(name) && args.size() == 1)
|
---|
388 | return new LengthFunction(args.get(0));
|
---|
389 | else if ("max".equals(name) && !args.isEmpty())
|
---|
390 | return new MinMaxFunction(args, true);
|
---|
391 | else if ("min".equals(name) && !args.isEmpty())
|
---|
392 | return new MinMaxFunction(args, false);
|
---|
393 | else if ("inside".equals(name) && args.size() == 1)
|
---|
394 | return new IsInsideFunction(args.get(0));
|
---|
395 | else if ("random".equals(name))
|
---|
396 | return env -> Math.random();
|
---|
397 |
|
---|
398 | Factory factory = FACTORY_MAP.get(name);
|
---|
399 | if (factory != null) {
|
---|
400 | return factory.createExpression(args);
|
---|
401 | }
|
---|
402 | return NullExpression.INSTANCE;
|
---|
403 | }
|
---|
404 |
|
---|
405 | /**
|
---|
406 | * Expression that always evaluates to null.
|
---|
407 | */
|
---|
408 | public static class NullExpression implements Expression {
|
---|
409 |
|
---|
410 | /**
|
---|
411 | * The unique instance.
|
---|
412 | */
|
---|
413 | public static final NullExpression INSTANCE = new NullExpression();
|
---|
414 |
|
---|
415 | @Override
|
---|
416 | public Object evaluate(Environment env) {
|
---|
417 | return null;
|
---|
418 | }
|
---|
419 | }
|
---|
420 |
|
---|
421 | /**
|
---|
422 | * Conditional operator.
|
---|
423 | */
|
---|
424 | public static class CondOperator implements Expression {
|
---|
425 |
|
---|
426 | private final Expression condition, firstOption, secondOption;
|
---|
427 |
|
---|
428 | /**
|
---|
429 | * Constructs a new {@code CondOperator}.
|
---|
430 | * @param condition condition
|
---|
431 | * @param firstOption first option
|
---|
432 | * @param secondOption second option
|
---|
433 | */
|
---|
434 | public CondOperator(Expression condition, Expression firstOption, Expression secondOption) {
|
---|
435 | this.condition = condition;
|
---|
436 | this.firstOption = firstOption;
|
---|
437 | this.secondOption = secondOption;
|
---|
438 | }
|
---|
439 |
|
---|
440 | @Override
|
---|
441 | public Object evaluate(Environment env) {
|
---|
442 | Boolean b = Cascade.convertTo(condition.evaluate(env), boolean.class);
|
---|
443 | if (b != null && b)
|
---|
444 | return firstOption.evaluate(env);
|
---|
445 | else
|
---|
446 | return secondOption.evaluate(env);
|
---|
447 | }
|
---|
448 | }
|
---|
449 |
|
---|
450 | /**
|
---|
451 | * "And" logical operator.
|
---|
452 | */
|
---|
453 | public static class AndOperator implements Expression {
|
---|
454 |
|
---|
455 | private final List<Expression> args;
|
---|
456 |
|
---|
457 | /**
|
---|
458 | * Constructs a new {@code AndOperator}.
|
---|
459 | * @param args arguments
|
---|
460 | */
|
---|
461 | public AndOperator(List<Expression> args) {
|
---|
462 | this.args = args;
|
---|
463 | }
|
---|
464 |
|
---|
465 | @Override
|
---|
466 | public Object evaluate(Environment env) {
|
---|
467 | return args.stream()
|
---|
468 | .map(arg -> Cascade.convertTo(arg.evaluate(env), boolean.class))
|
---|
469 | .allMatch(Boolean.TRUE::equals);
|
---|
470 | }
|
---|
471 | }
|
---|
472 |
|
---|
473 | /**
|
---|
474 | * "Or" logical operator.
|
---|
475 | */
|
---|
476 | public static class OrOperator implements Expression {
|
---|
477 |
|
---|
478 | private final List<Expression> args;
|
---|
479 |
|
---|
480 | /**
|
---|
481 | * Constructs a new {@code OrOperator}.
|
---|
482 | * @param args arguments
|
---|
483 | */
|
---|
484 | public OrOperator(List<Expression> args) {
|
---|
485 | this.args = args;
|
---|
486 | }
|
---|
487 |
|
---|
488 | @Override
|
---|
489 | public Object evaluate(Environment env) {
|
---|
490 | return args.stream()
|
---|
491 | .map(arg -> Cascade.convertTo(arg.evaluate(env), boolean.class))
|
---|
492 | .anyMatch(Boolean.TRUE::equals);
|
---|
493 | }
|
---|
494 | }
|
---|
495 |
|
---|
496 | /**
|
---|
497 | * Function to calculate the length of a string or list in a MapCSS eval expression.
|
---|
498 | * <p>
|
---|
499 | * Separate implementation to support overloading for different argument types.
|
---|
500 | * <p>
|
---|
501 | * The use for calculating the length of a list is deprecated, use
|
---|
502 | * {@link Functions#count(java.util.List)} instead (see #10061).
|
---|
503 | */
|
---|
504 | public static class LengthFunction implements Expression {
|
---|
505 |
|
---|
506 | private final Expression arg;
|
---|
507 |
|
---|
508 | /**
|
---|
509 | * Constructs a new {@code LengthFunction}.
|
---|
510 | * @param args arguments
|
---|
511 | */
|
---|
512 | public LengthFunction(Expression args) {
|
---|
513 | this.arg = args;
|
---|
514 | }
|
---|
515 |
|
---|
516 | @Override
|
---|
517 | public Object evaluate(Environment env) {
|
---|
518 | List<?> l = Cascade.convertTo(arg.evaluate(env), List.class);
|
---|
519 | if (l != null)
|
---|
520 | return l.size();
|
---|
521 | String s = Cascade.convertTo(arg.evaluate(env), String.class);
|
---|
522 | if (s != null)
|
---|
523 | return s.length();
|
---|
524 | return null;
|
---|
525 | }
|
---|
526 | }
|
---|
527 |
|
---|
528 | /**
|
---|
529 | * Computes the maximum/minimum value an arbitrary number of floats, or a list of floats.
|
---|
530 | */
|
---|
531 | public static class MinMaxFunction implements Expression {
|
---|
532 |
|
---|
533 | private final List<Expression> args;
|
---|
534 | private final boolean computeMax;
|
---|
535 |
|
---|
536 | /**
|
---|
537 | * Constructs a new {@code MinMaxFunction}.
|
---|
538 | * @param args arguments
|
---|
539 | * @param computeMax if {@code true}, compute max. If {@code false}, compute min
|
---|
540 | */
|
---|
541 | public MinMaxFunction(final List<Expression> args, final boolean computeMax) {
|
---|
542 | this.args = args;
|
---|
543 | this.computeMax = computeMax;
|
---|
544 | }
|
---|
545 |
|
---|
546 | /**
|
---|
547 | * Compute the minimum / maximum over the list
|
---|
548 | * @param lst The list
|
---|
549 | * @return The minimum or maximum depending on {@link #computeMax}
|
---|
550 | */
|
---|
551 | public Float aggregateList(List<?> lst) {
|
---|
552 | final List<Float> floats = Utils.transform(lst, (Function<Object, Float>) x -> Cascade.convertTo(x, float.class));
|
---|
553 | final Collection<Float> nonNullList = SubclassFilteredCollection.filter(floats, Objects::nonNull);
|
---|
554 | return nonNullList.isEmpty() ? (Float) Float.NaN : computeMax ? Collections.max(nonNullList) : Collections.min(nonNullList);
|
---|
555 | }
|
---|
556 |
|
---|
557 | @Override
|
---|
558 | public Object evaluate(final Environment env) {
|
---|
559 | List<?> l = Cascade.convertTo(args.get(0).evaluate(env), List.class);
|
---|
560 | if (args.size() != 1 || l == null)
|
---|
561 | l = Utils.transform(args, (Function<Expression, Object>) x -> x.evaluate(env));
|
---|
562 | return aggregateList(l);
|
---|
563 | }
|
---|
564 | }
|
---|
565 |
|
---|
566 | /**
|
---|
567 | * {@code Functions#inside} implementation for use in {@link org.openstreetmap.josm.data.validation.tests.MapCSSTagChecker}
|
---|
568 | *
|
---|
569 | * @see Functions#inside
|
---|
570 | */
|
---|
571 | public static class IsInsideFunction implements Expression {
|
---|
572 | private final Expression arg;
|
---|
573 |
|
---|
574 | /**
|
---|
575 | * Constructs a new {@code IsInsideFunction}.
|
---|
576 | * @param arg argument
|
---|
577 | */
|
---|
578 | public IsInsideFunction(Expression arg) {
|
---|
579 | this.arg = arg;
|
---|
580 | }
|
---|
581 |
|
---|
582 | /**
|
---|
583 | * Returns the argument
|
---|
584 | * @return the argument
|
---|
585 | */
|
---|
586 | public Expression getArg() {
|
---|
587 | return arg;
|
---|
588 | }
|
---|
589 |
|
---|
590 | @Override
|
---|
591 | public Object evaluate(Environment env) {
|
---|
592 | String codes = Cascade.convertTo(arg.evaluate(env), String.class);
|
---|
593 | return Functions.inside(env, codes);
|
---|
594 | }
|
---|
595 | }
|
---|
596 | }
|
---|