kopia lustrzana https://github.com/onthegomap/planetiler
402 wiersze
12 KiB
Java
402 wiersze
12 KiB
Java
|
package com.onthegomap.planetiler.expression;
|
||
|
|
||
|
import com.onthegomap.planetiler.reader.SourceFeature;
|
||
|
import com.onthegomap.planetiler.util.Format;
|
||
|
import java.util.ArrayList;
|
||
|
import java.util.HashSet;
|
||
|
import java.util.List;
|
||
|
import java.util.Objects;
|
||
|
import java.util.Set;
|
||
|
import java.util.function.Predicate;
|
||
|
import java.util.regex.Pattern;
|
||
|
import java.util.stream.Collectors;
|
||
|
import java.util.stream.Stream;
|
||
|
|
||
|
/**
|
||
|
* A framework for defining and manipulating boolean expressions that match on input element.
|
||
|
* <p>
|
||
|
* Calling {@code toString()} on any expression will generate code that can be used to recreate an identical copy of the
|
||
|
* original expression, assuming that the generated code includes:
|
||
|
* <pre>{@code
|
||
|
* import static com.onthegomap.planetiler.expression.Expression.*;
|
||
|
* }</pre>
|
||
|
*/
|
||
|
public interface Expression {
|
||
|
|
||
|
String LINESTRING_TYPE = "linestring";
|
||
|
String POINT_TYPE = "point";
|
||
|
String POLYGON_TYPE = "polygon";
|
||
|
String RELATION_MEMBER_TYPE = "relation_member";
|
||
|
|
||
|
Set<String> supportedTypes = Set.of(LINESTRING_TYPE, POINT_TYPE, POLYGON_TYPE, RELATION_MEMBER_TYPE);
|
||
|
Expression TRUE = new Expression() {
|
||
|
@Override
|
||
|
public String toString() {
|
||
|
return "TRUE";
|
||
|
}
|
||
|
|
||
|
@Override
|
||
|
public boolean evaluate(SourceFeature input, List<String> matchKeys) {
|
||
|
return true;
|
||
|
}
|
||
|
};
|
||
|
Expression FALSE = new Expression() {
|
||
|
public String toString() {
|
||
|
return "FALSE";
|
||
|
}
|
||
|
|
||
|
@Override
|
||
|
public boolean evaluate(SourceFeature input, List<String> matchKeys) {
|
||
|
return false;
|
||
|
}
|
||
|
};
|
||
|
|
||
|
static And and(Expression... children) {
|
||
|
return and(List.of(children));
|
||
|
}
|
||
|
|
||
|
static And and(List<Expression> children) {
|
||
|
return new And(children);
|
||
|
}
|
||
|
|
||
|
static Or or(Expression... children) {
|
||
|
return or(List.of(children));
|
||
|
}
|
||
|
|
||
|
static Or or(List<Expression> children) {
|
||
|
return new Or(children);
|
||
|
}
|
||
|
|
||
|
static Not not(Expression child) {
|
||
|
return new Not(child);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Returns an expression that evaluates to true if the value for {@code field} tag is any of {@code values}.
|
||
|
* <p>
|
||
|
* {@code values} can contain exact matches, "%text%" to match any value containing "text", or "" to match any value.
|
||
|
*/
|
||
|
static MatchAny matchAny(String field, String... values) {
|
||
|
return matchAny(field, List.of(values));
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Returns an expression that evaluates to true if the value for {@code field} tag is any of {@code values}.
|
||
|
* <p>
|
||
|
* {@code values} can contain exact matches, "%text%" to match any value containing "text", or "" to match any value.
|
||
|
*/
|
||
|
static MatchAny matchAny(String field, List<String> values) {
|
||
|
return new MatchAny(field, values);
|
||
|
}
|
||
|
|
||
|
/** Returns an expression that evaluates to true if the element has any value for tag {@code field}. */
|
||
|
static MatchField matchField(String field) {
|
||
|
return new MatchField(field);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Returns an expression that evaluates to true if the geometry of an element matches {@code type}.
|
||
|
* <p>
|
||
|
* Allowed values:
|
||
|
* <ul>
|
||
|
* <li>"linestring"</li>
|
||
|
* <li>"point"</li>
|
||
|
* <li>"polygon"</li>
|
||
|
* <li>"relation_member"</li>
|
||
|
* </ul>
|
||
|
*/
|
||
|
static MatchType matchType(String type) {
|
||
|
if (!supportedTypes.contains(type)) {
|
||
|
throw new IllegalArgumentException("Unsupported type: " + type);
|
||
|
}
|
||
|
return new MatchType(type);
|
||
|
}
|
||
|
|
||
|
private static String listToString(List<?> items) {
|
||
|
return items.stream().map(Object::toString).collect(Collectors.joining(", "));
|
||
|
}
|
||
|
|
||
|
private static Expression simplify(Expression initial) {
|
||
|
// iteratively simplify the expression until we reach a fixed point and start seeing
|
||
|
// an expression that's already been seen before
|
||
|
Expression simplified = initial;
|
||
|
Set<Expression> seen = new HashSet<>();
|
||
|
seen.add(simplified);
|
||
|
while (true) {
|
||
|
simplified = simplifyOnce(simplified);
|
||
|
if (seen.contains(simplified) || seen.size() > 100) {
|
||
|
return simplified;
|
||
|
}
|
||
|
seen.add(simplified);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
private static Expression simplifyOnce(Expression expression) {
|
||
|
if (expression instanceof Not not) {
|
||
|
if (not.child instanceof Or or) {
|
||
|
return and(or.children.stream().<Expression>map(Expression::not).toList());
|
||
|
} else if (not.child instanceof And and) {
|
||
|
return or(and.children.stream().<Expression>map(Expression::not).toList());
|
||
|
} else if (not.child instanceof Not not2) {
|
||
|
return not2.child;
|
||
|
} else if (not.child == TRUE) {
|
||
|
return FALSE;
|
||
|
} else if (not.child == FALSE) {
|
||
|
return TRUE;
|
||
|
}
|
||
|
return not;
|
||
|
} else if (expression instanceof Or or) {
|
||
|
if (or.children.isEmpty()) {
|
||
|
return FALSE;
|
||
|
}
|
||
|
if (or.children.size() == 1) {
|
||
|
return simplifyOnce(or.children.get(0));
|
||
|
}
|
||
|
if (or.children.contains(TRUE)) {
|
||
|
return TRUE;
|
||
|
}
|
||
|
return or(or.children.stream()
|
||
|
// hoist children
|
||
|
.flatMap(child -> child instanceof Or childOr ? childOr.children.stream() : Stream.of(child))
|
||
|
.filter(child -> child != FALSE)
|
||
|
.map(Expression::simplifyOnce).toList());
|
||
|
} else if (expression instanceof And and) {
|
||
|
if (and.children.isEmpty()) {
|
||
|
return FALSE;
|
||
|
}
|
||
|
if (and.children.size() == 1) {
|
||
|
return simplifyOnce(and.children.get(0));
|
||
|
}
|
||
|
if (and.children.contains(FALSE)) {
|
||
|
return FALSE;
|
||
|
}
|
||
|
return and(and.children.stream()
|
||
|
// hoist children
|
||
|
.flatMap(child -> child instanceof And childAnd ? childAnd.children.stream() : Stream.of(child))
|
||
|
.filter(child -> child != TRUE)
|
||
|
.map(Expression::simplifyOnce).toList());
|
||
|
} else {
|
||
|
return expression;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/** Returns an equivalent, simplified copy of this expression but does not modify {@code this}. */
|
||
|
default Expression simplify() {
|
||
|
return simplify(this);
|
||
|
}
|
||
|
|
||
|
/** Returns a copy of this expression where every nested instance of {@code a} is replaced with {@code b}. */
|
||
|
default Expression replace(Expression a, Expression b) {
|
||
|
return replace(a::equals, b);
|
||
|
}
|
||
|
|
||
|
/** Returns a copy of this expression where every nested instance matching {@code replace} is replaced with {@code b}. */
|
||
|
default Expression replace(Predicate<Expression> replace, Expression b) {
|
||
|
if (replace.test(this)) {
|
||
|
return b;
|
||
|
} else if (this instanceof Not not) {
|
||
|
return new Not(not.child.replace(replace, b));
|
||
|
} else if (this instanceof Or or) {
|
||
|
return new Or(or.children.stream().map(child -> child.replace(replace, b)).toList());
|
||
|
} else if (this instanceof And and) {
|
||
|
return new And(and.children.stream().map(child -> child.replace(replace, b)).toList());
|
||
|
} else {
|
||
|
return this;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/** Returns true if this expression or any subexpression matches {@code filter}. */
|
||
|
default boolean contains(Predicate<Expression> filter) {
|
||
|
if (filter.test(this)) {
|
||
|
return true;
|
||
|
} else if (this instanceof Not not) {
|
||
|
return not.child.contains(filter);
|
||
|
} else if (this instanceof Or or) {
|
||
|
return or.children.stream().anyMatch(child -> child.contains(filter));
|
||
|
} else if (this instanceof And and) {
|
||
|
return and.children.stream().anyMatch(child -> child.contains(filter));
|
||
|
} else {
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Returns true if this expression matches an input element.
|
||
|
*
|
||
|
* @param input the input element
|
||
|
* @param matchKeys list that this method call will add any key to that was responsible for triggering the match
|
||
|
* @return true if this expression matches the input element
|
||
|
*/
|
||
|
boolean evaluate(SourceFeature input, List<String> matchKeys);
|
||
|
|
||
|
record And(List<Expression> children) implements Expression {
|
||
|
|
||
|
@Override
|
||
|
public String toString() {
|
||
|
return "and(" + listToString(children) + ")";
|
||
|
}
|
||
|
|
||
|
@Override
|
||
|
public boolean evaluate(SourceFeature input, List<String> matchKeys) {
|
||
|
for (Expression child : children) {
|
||
|
if (!child.evaluate(input, matchKeys)) {
|
||
|
matchKeys.clear();
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
record Or(List<Expression> children) implements Expression {
|
||
|
|
||
|
@Override
|
||
|
public String toString() {
|
||
|
return "or(" + listToString(children) + ")";
|
||
|
}
|
||
|
|
||
|
@Override
|
||
|
public boolean evaluate(SourceFeature input, List<String> matchKeys) {
|
||
|
int size = children.size();
|
||
|
// Optimization: this method consumes the most time when matching against input elements, and
|
||
|
// iterating through this list by index is slightly faster than an enhanced for loop
|
||
|
// noinspection ForLoopReplaceableByForEach - for intellij
|
||
|
for (int i = 0; i < size; i++) {
|
||
|
Expression child = children.get(i);
|
||
|
if (child.evaluate(input, matchKeys)) {
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
@Override
|
||
|
public boolean equals(Object obj) {
|
||
|
if (obj == this) {
|
||
|
return true;
|
||
|
}
|
||
|
if (obj == null || obj.getClass() != this.getClass()) {
|
||
|
return false;
|
||
|
}
|
||
|
var that = (Or) obj;
|
||
|
return Objects.equals(this.children, that.children);
|
||
|
}
|
||
|
|
||
|
@Override
|
||
|
public int hashCode() {
|
||
|
return Objects.hash(children);
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
record Not(Expression child) implements Expression {
|
||
|
|
||
|
@Override
|
||
|
public String toString() {
|
||
|
return "not(" + child + ")";
|
||
|
}
|
||
|
|
||
|
@Override
|
||
|
public boolean evaluate(SourceFeature input, List<String> matchKeys) {
|
||
|
return !child.evaluate(input, new ArrayList<>());
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Evaluates to true if the value for {@code field} tag is any of {@code exactMatches} or contains any of {@code
|
||
|
* wildcards}.
|
||
|
*
|
||
|
* @param values all raw string values that were initially provided
|
||
|
* @param exactMatches the input {@code values} that should be treated as exact matches
|
||
|
* @param wildcards the input {@code values} that should be treated as wildcards
|
||
|
* @param matchWhenMissing if {@code values} contained ""
|
||
|
*/
|
||
|
record MatchAny(
|
||
|
String field, List<String> values, Set<String> exactMatches, List<String> wildcards, boolean matchWhenMissing
|
||
|
) implements Expression {
|
||
|
|
||
|
private static final Pattern containsPattern = Pattern.compile("^%(.*)%$");
|
||
|
|
||
|
MatchAny(String field, List<String> values) {
|
||
|
this(field, values,
|
||
|
values.stream().filter(v -> !v.contains("%")).collect(Collectors.toSet()),
|
||
|
values.stream().filter(v -> v.contains("%")).map(val -> {
|
||
|
var matcher = containsPattern.matcher(val);
|
||
|
if (!matcher.matches()) {
|
||
|
throw new IllegalArgumentException("wildcards must start/end with %: " + val);
|
||
|
}
|
||
|
return matcher.group(1);
|
||
|
}).toList(),
|
||
|
values.contains("")
|
||
|
);
|
||
|
}
|
||
|
|
||
|
@Override
|
||
|
public boolean evaluate(SourceFeature input, List<String> matchKeys) {
|
||
|
Object value = input.getTag(field);
|
||
|
if (value == null) {
|
||
|
return matchWhenMissing;
|
||
|
} else {
|
||
|
String str = value.toString();
|
||
|
if (exactMatches.contains(str)) {
|
||
|
matchKeys.add(field);
|
||
|
return true;
|
||
|
}
|
||
|
for (String target : wildcards) {
|
||
|
if (str.contains(target)) {
|
||
|
matchKeys.add(field);
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
@Override
|
||
|
public String toString() {
|
||
|
return "matchAny(" + Format.quote(field) + ", " + values.stream().map(Format::quote)
|
||
|
.collect(Collectors.joining(", ")) + ")";
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/** Evaluates to true if an input element contains any value for {@code field} tag. */
|
||
|
record MatchField(String field) implements Expression {
|
||
|
|
||
|
@Override
|
||
|
public String toString() {
|
||
|
return "matchField(" + Format.quote(field) + ")";
|
||
|
}
|
||
|
|
||
|
@Override
|
||
|
public boolean evaluate(SourceFeature input, List<String> matchKeys) {
|
||
|
if (input.hasTag(field)) {
|
||
|
matchKeys.add(field);
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Evaluates to true if an input element has geometry type matching {@code type}.
|
||
|
*/
|
||
|
record MatchType(String type) implements Expression {
|
||
|
|
||
|
@Override
|
||
|
public String toString() {
|
||
|
return "matchType(" + Format.quote(type) + ")";
|
||
|
}
|
||
|
|
||
|
@Override
|
||
|
public boolean evaluate(SourceFeature input, List<String> matchKeys) {
|
||
|
return switch (type) {
|
||
|
case LINESTRING_TYPE -> input.canBeLine();
|
||
|
case POLYGON_TYPE -> input.canBePolygon();
|
||
|
case POINT_TYPE -> input.isPoint();
|
||
|
case RELATION_MEMBER_TYPE -> input.hasRelationInfo();
|
||
|
default -> false;
|
||
|
};
|
||
|
}
|
||
|
}
|
||
|
}
|