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}