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}