001// License: GPL. For details, see LICENSE file.
002package org.openstreetmap.josm.tools;
003
004import java.util.Collection;
005import java.util.Objects;
006import java.util.regex.Pattern;
007
008import org.openstreetmap.josm.data.osm.OsmPrimitive;
009
010/**
011 * Utility class for creating {@link Predicate}s.
012 */
013public final class Predicates {
014
015    private Predicates() {
016    }
017
018    /**
019     * Returns the negation of {@code predicate}.
020     * @param <T> type of items
021     * @param predicate the predicate to negate
022     * @return the negation of {@code predicate}
023     */
024    public static <T> Predicate<T> not(final Predicate<T> predicate) {
025        return new Predicate<T>() {
026            @Override
027            public boolean evaluate(T obj) {
028                return !predicate.evaluate(obj);
029            }
030        };
031    }
032
033    /**
034     * Returns a {@link Predicate} executing {@link Objects#equals}.
035     * @param <T> type of items
036     * @param ref the reference object
037     * @return a {@link Predicate} executing {@link Objects#equals}
038     */
039    public static <T> Predicate<T> equalTo(final T ref) {
040        return new Predicate<T>() {
041            @Override
042            public boolean evaluate(T obj) {
043                return Objects.equals(obj, ref);
044            }
045        };
046    }
047
048    /**
049     * Returns a {@link Predicate} executing {@link Pattern#matcher(CharSequence)} and {@link java.util.regex.Matcher#matches}.
050     * @param pattern the pattern
051     * @return a {@link Predicate} executing {@link Pattern#matcher(CharSequence)} and {@link java.util.regex.Matcher#matches}
052     */
053    public static Predicate<String> stringMatchesPattern(final Pattern pattern) {
054        return new Predicate<String>() {
055            @Override
056            public boolean evaluate(String string) {
057                return pattern.matcher(string).matches();
058            }
059        };
060    }
061
062    /**
063     * Returns a {@link Predicate} executing {@link Pattern#matcher(CharSequence)} and {@link java.util.regex.Matcher#find}.
064     * @param pattern the pattern
065     * @return a {@link Predicate} executing {@link Pattern#matcher(CharSequence)} and {@link java.util.regex.Matcher#find}
066     */
067    public static Predicate<String> stringContainsPattern(final Pattern pattern) {
068        return new Predicate<String>() {
069            @Override
070            public boolean evaluate(String string) {
071                return pattern.matcher(string).find();
072            }
073        };
074    }
075
076    /**
077     * Returns a {@link Predicate} executing {@link String#contains(CharSequence)}.
078     * @param pattern the pattern
079     * @return a {@link Predicate} executing {@link String#contains(CharSequence)}
080     */
081    public static Predicate<String> stringContains(final String pattern) {
082        return new Predicate<String>() {
083            @Override
084            public boolean evaluate(String string) {
085                return string.contains(pattern);
086            }
087        };
088    }
089
090    /**
091     * Returns a {@link Predicate} executing {@link OsmPrimitive#hasTag(String, String...)}.
092     * @param key the key forming the tag
093     * @param values one or many values forming the tag
094     * @return a {@link Predicate} executing {@link OsmPrimitive#hasTag(String, String...)}
095     */
096    public static Predicate<OsmPrimitive> hasTag(final String key, final String... values) {
097        return new Predicate<OsmPrimitive>() {
098            @Override
099            public boolean evaluate(OsmPrimitive p) {
100                return p.hasTag(key, values);
101            }
102        };
103    }
104
105    /**
106     * Returns a {@link Predicate} executing {@link OsmPrimitive#hasKey(String)}.
107     * @param key the key
108     * @return a {@link Predicate} executing {@link OsmPrimitive#hasKey(String)}
109     */
110    public static Predicate<OsmPrimitive> hasKey(final String key) {
111        return new Predicate<OsmPrimitive>() {
112            @Override
113            public boolean evaluate(OsmPrimitive p) {
114                return p.hasKey(key);
115            }
116        };
117    }
118
119    /**
120     * Returns a {@link Predicate} executing {@link Collection#contains(Object)}.
121     * @param <T> type of items
122     * @param target collection
123     * @return a {@link Predicate} executing {@link Collection#contains(Object)}
124     */
125    public static <T> Predicate<T> inCollection(final Collection<? extends T> target) {
126        return new Predicate<T>() {
127            @Override
128            public boolean evaluate(T object) {
129                return target.contains(object);
130            }
131        };
132    }
133
134    /**
135     * Returns a {@link Predicate} testing whether objects are {@code null}.
136     * @param <T> type of items
137     * @return a {@link Predicate} testing whether objects are {@code null}
138     */
139    public static <T> Predicate<T> isNull() {
140        return new Predicate<T>() {
141            @Override
142            public boolean evaluate(T object) {
143                return object == null;
144            }
145        };
146    }
147}