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 predicate the predicate to negate
021     * @return the negation of {@code predicate}
022     */
023    public static <T> Predicate<T> not(final Predicate<T> predicate) {
024        return new Predicate<T>() {
025            @Override
026            public boolean evaluate(T obj) {
027                return !predicate.evaluate(obj);
028            }
029        };
030    }
031
032    /**
033     * Returns a {@link Predicate} executing {@link Objects#equals}.
034     * @param ref the reference object
035     * @return a {@link Predicate} executing {@link Objects#equals}
036     */
037    public static <T> Predicate<T> equalTo(final T ref) {
038        return new Predicate<T>() {
039            @Override
040            public boolean evaluate(T obj) {
041                return Objects.equals(obj, ref);
042            }
043        };
044    }
045
046    /**
047     * Returns a {@link Predicate} executing {@link Pattern#matcher(CharSequence)} and {@link java.util.regex.Matcher#matches}.
048     * @param pattern the pattern
049     * @return a {@link Predicate} executing {@link Pattern#matcher(CharSequence)} and {@link java.util.regex.Matcher#matches}
050     */
051    public static Predicate<String> stringMatchesPattern(final Pattern pattern) {
052        return new Predicate<String>() {
053            @Override
054            public boolean evaluate(String string) {
055                return pattern.matcher(string).matches();
056            }
057        };
058    }
059
060    /**
061     * Returns a {@link Predicate} executing {@link Pattern#matcher(CharSequence)} and {@link java.util.regex.Matcher#find}.
062     * @param pattern the pattern
063     * @return a {@link Predicate} executing {@link Pattern#matcher(CharSequence)} and {@link java.util.regex.Matcher#find}
064     */
065    public static Predicate<String> stringContainsPattern(final Pattern pattern) {
066        return new Predicate<String>() {
067            @Override
068            public boolean evaluate(String string) {
069                return pattern.matcher(string).find();
070            }
071        };
072    }
073
074    /**
075     * Returns a {@link Predicate} executing {@link String#contains(CharSequence)}.
076     * @param pattern the pattern
077     * @return a {@link Predicate} executing {@link String#contains(CharSequence)}
078     */
079    public static Predicate<String> stringContains(final String pattern) {
080        return new Predicate<String>() {
081            @Override
082            public boolean evaluate(String string) {
083                return string.contains(pattern);
084            }
085        };
086    }
087
088    /**
089     * Returns a {@link Predicate} executing {@link OsmPrimitive#hasTag(String, String...)}.
090     * @param key the key forming the tag
091     * @param values one or many values forming the tag
092     * @return a {@link Predicate} executing {@link OsmPrimitive#hasTag(String, String...)}
093     */
094    public static Predicate<OsmPrimitive> hasTag(final String key, final String... values) {
095        return new Predicate<OsmPrimitive>() {
096            @Override
097            public boolean evaluate(OsmPrimitive p) {
098                return p.hasTag(key, values);
099            }
100        };
101    }
102
103    /**
104     * Returns a {@link Predicate} executing {@link OsmPrimitive#hasKey(String)}.
105     * @param key the key
106     * @return a {@link Predicate} executing {@link OsmPrimitive#hasKey(String)}
107     */
108    public static Predicate<OsmPrimitive> hasKey(final String key) {
109        return new Predicate<OsmPrimitive>() {
110            @Override
111            public boolean evaluate(OsmPrimitive p) {
112                return p.hasKey(key);
113            }
114        };
115    }
116
117    /**
118     * Returns a {@link Predicate} executing {@link Collection#contains(Object)}.
119     * @param target collection
120     * @return a {@link Predicate} executing {@link Collection#contains(Object)}
121     */
122    public static <T> Predicate<T> inCollection(final Collection<? extends T> target) {
123        return new Predicate<T>() {
124            @Override
125            public boolean evaluate(T object) {
126                return target.contains(object);
127            }
128        };
129    }
130
131    /**
132     * Returns a {@link Predicate} testing whether objects are {@code null}.
133     * @return a {@link Predicate} testing whether objects are {@code null}
134     */
135    public static <T> Predicate<T> isNull() {
136        return new Predicate<T>() {
137            @Override
138            public boolean evaluate(T object) {
139                return object == null;
140            }
141        };
142    }
143}