Index: /trunk/src/org/openstreetmap/josm/data/osm/DataSet.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/osm/DataSet.java (revision 10690) +++ /trunk/src/org/openstreetmap/josm/data/osm/DataSet.java (revision 10691) @@ -21,4 +21,5 @@ import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; +import java.util.function.Predicate; import org.openstreetmap.josm.Main; @@ -319,5 +320,5 @@ * @since 10590 */ - public Collection getPrimitives(java.util.function.Predicate predicate) { + public Collection getPrimitives(Predicate predicate) { return new SubclassFilteredCollection<>(allPrimitives, predicate); } Index: /trunk/src/org/openstreetmap/josm/gui/dialogs/properties/PropertiesDialog.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/dialogs/properties/PropertiesDialog.java (revision 10690) +++ /trunk/src/org/openstreetmap/josm/gui/dialogs/properties/PropertiesDialog.java (revision 10691) @@ -896,5 +896,5 @@ positionString = Utils.getPositionListString(position); // if not all objects from the selection are member of this relation - if (selection.stream().anyMatch(Predicates.not(Predicates.inCollection(members)))) { + if (selection.stream().anyMatch(Predicates.inCollection(members).negate())) { positionString += ",\u2717"; } Index: /trunk/src/org/openstreetmap/josm/gui/mappaint/mapcss/ExpressionFactory.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/mappaint/mapcss/ExpressionFactory.java (revision 10690) +++ /trunk/src/org/openstreetmap/josm/gui/mappaint/mapcss/ExpressionFactory.java (revision 10691) @@ -1135,5 +1135,5 @@ public Float aggregateList(List lst) { final List floats = Utils.transform(lst, (Function) x -> Cascade.convertTo(x, float.class)); - final Collection nonNullList = SubclassFilteredCollection.filter(floats, Predicates.not(Predicates.isNull())); + final Collection nonNullList = SubclassFilteredCollection.filter(floats, Predicates.isNull().negate()); return nonNullList.isEmpty() ? (Float) Float.NaN : computeMax ? Collections.max(nonNullList) : Collections.min(nonNullList); } Index: /trunk/src/org/openstreetmap/josm/tools/FilteredCollection.java =================================================================== --- /trunk/src/org/openstreetmap/josm/tools/FilteredCollection.java (revision 10690) +++ /trunk/src/org/openstreetmap/josm/tools/FilteredCollection.java (revision 10691) @@ -3,4 +3,5 @@ import java.util.Collection; +import java.util.function.Predicate; /** @@ -17,5 +18,5 @@ * @param predicate The predicate to use as filter */ - public FilteredCollection(Collection collection, java.util.function.Predicate predicate) { + public FilteredCollection(Collection collection, Predicate predicate) { super(collection, predicate); } Index: /trunk/src/org/openstreetmap/josm/tools/Geometry.java =================================================================== --- /trunk/src/org/openstreetmap/josm/tools/Geometry.java (revision 10690) +++ /trunk/src/org/openstreetmap/josm/tools/Geometry.java (revision 10691) @@ -16,4 +16,5 @@ import java.util.List; import java.util.Set; +import java.util.function.Predicate; import org.openstreetmap.josm.Main; @@ -887,5 +888,5 @@ * @return {@code true} if the node is inside the multipolygon */ - public static boolean isNodeInsideMultiPolygon(Node node, Relation multiPolygon, java.util.function.Predicate isOuterWayAMatch) { + public static boolean isNodeInsideMultiPolygon(Node node, Relation multiPolygon, Predicate isOuterWayAMatch) { return isPolygonInsideMultiPolygon(Collections.singletonList(node), multiPolygon, isOuterWayAMatch); } @@ -901,6 +902,5 @@ * @return {@code true} if the polygon formed by nodes is inside the multipolygon */ - public static boolean isPolygonInsideMultiPolygon(List nodes, Relation multiPolygon, - java.util.function.Predicate isOuterWayAMatch) { + public static boolean isPolygonInsideMultiPolygon(List nodes, Relation multiPolygon, Predicate isOuterWayAMatch) { // Extract outer/inner members from multipolygon final MultiPolygonMembers mpm = new MultiPolygonMembers(multiPolygon); Index: unk/src/org/openstreetmap/josm/tools/Predicate.java =================================================================== --- /trunk/src/org/openstreetmap/josm/tools/Predicate.java (revision 10690) +++ (revision ) @@ -1,26 +1,0 @@ -// License: GPL. For details, see LICENSE file. -package org.openstreetmap.josm.tools; - -/** - * Used to identify objects that fulfill a certain condition, e.g. when filtering a collection. - * - * @param The objects type - * @since 3177 - * @deprecated Use {@link java.util.function.Predicate} instead. - */ -@Deprecated -@FunctionalInterface -public interface Predicate extends java.util.function.Predicate { - - /** - * Determines whether the object passes the test or not - * @param object The object to evaluate - * @return {@code true} if the object passes the test, {@code false} otherwise - */ - boolean evaluate(T object); - - @Override - default boolean test(T t) { - return evaluate(t); - } -} Index: /trunk/src/org/openstreetmap/josm/tools/Predicates.java =================================================================== --- /trunk/src/org/openstreetmap/josm/tools/Predicates.java (revision 10690) +++ /trunk/src/org/openstreetmap/josm/tools/Predicates.java (revision 10691) @@ -4,4 +4,5 @@ import java.util.Collection; import java.util.Objects; +import java.util.function.Predicate; import java.util.regex.Pattern; @@ -34,16 +35,4 @@ public static Predicate alwaysFalse() { return o -> false; - } - - /** - * Returns the negation of {@code predicate}. - * @param type of items - * @param predicate the predicate to negate - * @return the negation of {@code predicate} - * @deprecated Use {@link java.util.function.Predicate#negate()} - */ - @Deprecated - public static Predicate not(final Predicate predicate) { - return obj -> !predicate.evaluate(obj); } Index: /trunk/src/org/openstreetmap/josm/tools/SubclassFilteredCollection.java =================================================================== --- /trunk/src/org/openstreetmap/josm/tools/SubclassFilteredCollection.java (revision 10690) +++ /trunk/src/org/openstreetmap/josm/tools/SubclassFilteredCollection.java (revision 10691) @@ -6,4 +6,5 @@ import java.util.Iterator; import java.util.NoSuchElementException; +import java.util.function.Predicate; /** @@ -22,5 +23,5 @@ private final Collection collection; - private final java.util.function.Predicate predicate; + private final Predicate predicate; private int size = -1; @@ -72,18 +73,7 @@ * @param collection The base collection to filter * @param predicate The predicate to use as filter - * @deprecated Use java predicates instead. + * @see #filter(Collection, Predicate) for an alternative way to construct this. */ - @Deprecated public SubclassFilteredCollection(Collection collection, Predicate predicate) { - this(collection, (java.util.function.Predicate) predicate); - } - - /** - * Constructs a new {@code SubclassFilteredCollection}. - * @param collection The base collection to filter - * @param predicate The predicate to use as filter - * @see #filter(Collection, java.util.function.Predicate) for an alternative way to construct this. - */ - public SubclassFilteredCollection(Collection collection, java.util.function.Predicate predicate) { this.collection = collection; this.predicate = predicate; @@ -120,5 +110,5 @@ * @return The filtered collection. It is a {@code Collection}. */ - public static SubclassFilteredCollection filter(Collection collection, java.util.function.Predicate predicate) { + public static SubclassFilteredCollection filter(Collection collection, Predicate predicate) { return new SubclassFilteredCollection<>(collection, predicate); } Index: /trunk/src/org/openstreetmap/josm/tools/Utils.java =================================================================== --- /trunk/src/org/openstreetmap/josm/tools/Utils.java (revision 10690) +++ /trunk/src/org/openstreetmap/josm/tools/Utils.java (revision 10691) @@ -50,4 +50,5 @@ import java.util.concurrent.ThreadFactory; import java.util.concurrent.atomic.AtomicLong; +import java.util.function.Predicate; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -106,10 +107,10 @@ * @param predicate the predicate * @return {@code true} if {@code predicate} applies to at least one element from {@code collection} - * @deprecated use {@link Stream#anyMatch(java.util.function.Predicate)} instead. + * @deprecated use {@link Stream#anyMatch(Predicate)} instead. */ @Deprecated public static boolean exists(Iterable collection, Predicate predicate) { for (T item : collection) { - if (predicate.evaluate(item)) { + if (predicate.test(item)) { return true; } @@ -125,9 +126,9 @@ * @param predicate the predicate * @return {@code true} if {@code predicate} applies to all elements from {@code collection} - * @deprecated use {@link Stream#allMatch(java.util.function.Predicate)} instead. + * @deprecated use {@link Stream#allMatch(Predicate)} instead. */ @Deprecated public static boolean forAll(Iterable collection, Predicate predicate) { - return !exists(collection, Predicates.not(predicate)); + return !exists(collection, predicate.negate()); } @@ -152,5 +153,5 @@ public static T find(Iterable collection, Predicate predicate) { for (T item : collection) { - if (predicate.evaluate(item)) { + if (predicate.test(item)) { return item; } @@ -169,19 +170,4 @@ public static T find(Iterable collection, Class clazz) { return (T) find(collection, Predicates.isInstanceOf(clazz)); - } - - /** - * Creates a new {@link FilteredCollection}. - * @param The collection type. - * @param collection The collection to filter. - * @param predicate The predicate to filter for. - * @return The new {@link FilteredCollection} - * @deprecated Use java predicates and {@link SubclassFilteredCollection#filter(Collection, java.util.function.Predicate)} instead. - */ - @Deprecated - @SuppressWarnings("unused") - public static Collection filter(Collection collection, Predicate predicate) { - // Diamond operator does not work with Java 9 here - return new FilteredCollection(collection, predicate); } @@ -225,5 +211,5 @@ int i = 0; for (T item : collection) { - if (predicate.evaluate(item)) + if (predicate.test(item)) return i; i++; @@ -758,25 +744,4 @@ public static String escapeReservedCharactersHTML(String s) { return s == null ? "" : s.replace("&", "&").replace("<", "<").replace(">", ">"); - } - - /** - * Represents a function that can be applied to objects of {@code A} and - * returns objects of {@code B}. - * @param class of input objects - * @param class of transformed objects - * - * @deprecated Use java.util.function.Function instead. - */ - @Deprecated - @FunctionalInterface - public interface Function extends java.util.function.Function { - - /** - * Applies the function on {@code x}. - * @param x an object of - * @return the transformed object - */ - @Override - B apply(A x); } Index: /trunk/test/unit/org/CustomMatchers.java =================================================================== --- /trunk/test/unit/org/CustomMatchers.java (revision 10690) +++ /trunk/test/unit/org/CustomMatchers.java (revision 10691) @@ -4,4 +4,5 @@ import java.awt.geom.Point2D; import java.util.Collection; +import java.util.function.Predicate; import org.hamcrest.CustomTypeSafeMatcher; @@ -12,5 +13,4 @@ import org.openstreetmap.josm.data.coor.EastNorth; import org.openstreetmap.josm.data.coor.LatLon; -import org.openstreetmap.josm.tools.Predicate; /** @@ -35,5 +35,5 @@ @Override protected boolean matchesSafely(T item) { - return predicate.evaluate(item); + return predicate.test(item); } Index: /trunk/test/unit/org/openstreetmap/josm/tools/PredicatesTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/tools/PredicatesTest.java (revision 10690) +++ /trunk/test/unit/org/openstreetmap/josm/tools/PredicatesTest.java (revision 10691) @@ -9,4 +9,5 @@ import java.util.List; import java.util.Properties; +import java.util.function.Predicate; import java.util.regex.Pattern; @@ -38,6 +39,6 @@ public void testAlwaysTrue() { Predicate alwaysTrue = Predicates.alwaysTrue(); - assertTrue(alwaysTrue.evaluate(new Object())); - assertTrue(alwaysTrue.evaluate(Boolean.TRUE)); + assertTrue(alwaysTrue.test(new Object())); + assertTrue(alwaysTrue.test(Boolean.TRUE)); } @@ -48,21 +49,6 @@ public void testAlwaysFalse() { Predicate alwaysFalse = Predicates.alwaysFalse(); - assertFalse(alwaysFalse.evaluate(new Object())); - assertFalse(alwaysFalse.evaluate(Boolean.TRUE)); - } - - /** - * Test {@link Predicates#not(Predicate)} - */ - @Test - public void testNot() { - Predicate not = Predicates.not(new Predicate() { - @Override - public boolean evaluate(Boolean object) { - return object; - } - }); - assertFalse(not.evaluate(Boolean.TRUE)); - assertTrue(not.evaluate(Boolean.FALSE)); + assertFalse(alwaysFalse.test(new Object())); + assertFalse(alwaysFalse.test(Boolean.TRUE)); } @@ -74,9 +60,9 @@ Integer testObject = Integer.valueOf(1); Predicate equalTo = Predicates.equalTo(testObject); - assertTrue(equalTo.evaluate(testObject)); - assertTrue(equalTo.evaluate(Integer.valueOf(1))); + assertTrue(equalTo.test(testObject)); + assertTrue(equalTo.test(Integer.valueOf(1))); - assertFalse(equalTo.evaluate(Integer.valueOf(2))); - assertFalse(equalTo.evaluate(null)); + assertFalse(equalTo.test(Integer.valueOf(2))); + assertFalse(equalTo.test(null)); } @@ -87,8 +73,8 @@ public void testIsOfClass() { Predicate isOfClass = Predicates.isOfClass(Hashtable.class); - assertFalse(isOfClass.evaluate(null)); - assertFalse(isOfClass.evaluate(new Object())); - assertFalse(isOfClass.evaluate(new Properties())); - assertTrue(isOfClass.evaluate(new Hashtable<>())); + assertFalse(isOfClass.test(null)); + assertFalse(isOfClass.test(new Object())); + assertFalse(isOfClass.test(new Properties())); + assertTrue(isOfClass.test(new Hashtable<>())); } @@ -99,8 +85,8 @@ public void testIsInstanceOf() { Predicate isInstanceOf = Predicates.isInstanceOf(Hashtable.class); - assertFalse(isInstanceOf.evaluate(null)); - assertFalse(isInstanceOf.evaluate(new Object())); - assertTrue(isInstanceOf.evaluate(new Properties())); - assertTrue(isInstanceOf.evaluate(new Hashtable<>())); + assertFalse(isInstanceOf.test(null)); + assertFalse(isInstanceOf.test(new Object())); + assertTrue(isInstanceOf.test(new Properties())); + assertTrue(isInstanceOf.test(new Hashtable<>())); } @@ -112,9 +98,9 @@ Pattern p = Pattern.compile("ab?c"); Predicate stringMatchesPattern = Predicates.stringMatchesPattern(p); - assertFalse(stringMatchesPattern.evaluate("")); - assertFalse(stringMatchesPattern.evaluate("a")); - assertFalse(stringMatchesPattern.evaluate("xabcx")); - assertTrue(stringMatchesPattern.evaluate("ac")); - assertTrue(stringMatchesPattern.evaluate("abc")); + assertFalse(stringMatchesPattern.test("")); + assertFalse(stringMatchesPattern.test("a")); + assertFalse(stringMatchesPattern.test("xabcx")); + assertTrue(stringMatchesPattern.test("ac")); + assertTrue(stringMatchesPattern.test("abc")); } @@ -126,10 +112,10 @@ Pattern p = Pattern.compile("ab?c"); Predicate stringContainsPattern = Predicates.stringContainsPattern(p); - assertFalse(stringContainsPattern.evaluate("")); - assertFalse(stringContainsPattern.evaluate("a")); - assertTrue(stringContainsPattern.evaluate("xabcx")); - assertTrue(stringContainsPattern.evaluate("ac")); - assertTrue(stringContainsPattern.evaluate("abc")); - assertTrue(stringContainsPattern.evaluate("xx\nabc\nx")); + assertFalse(stringContainsPattern.test("")); + assertFalse(stringContainsPattern.test("a")); + assertTrue(stringContainsPattern.test("xabcx")); + assertTrue(stringContainsPattern.test("ac")); + assertTrue(stringContainsPattern.test("abc")); + assertTrue(stringContainsPattern.test("xx\nabc\nx")); } @@ -140,9 +126,9 @@ public void testStringContains() { Predicate stringContains = Predicates.stringContains("abc"); - assertFalse(stringContains.evaluate("")); - assertFalse(stringContains.evaluate("a")); - assertTrue(stringContains.evaluate("xabcx")); - assertFalse(stringContains.evaluate("ac")); - assertTrue(stringContains.evaluate("abc")); + assertFalse(stringContains.test("")); + assertFalse(stringContains.test("a")); + assertTrue(stringContains.test("xabcx")); + assertFalse(stringContains.test("ac")); + assertTrue(stringContains.test("abc")); } @@ -154,11 +140,11 @@ Predicate hasTag = Predicates.hasTag("key", "value"); Node n1 = new Node(); - assertFalse(hasTag.evaluate(n1)); + assertFalse(hasTag.test(n1)); n1.put("Key", "x"); - assertFalse(hasTag.evaluate(n1)); + assertFalse(hasTag.test(n1)); n1.put("key", "x"); - assertFalse(hasTag.evaluate(n1)); + assertFalse(hasTag.test(n1)); n1.put("key", "value"); - assertTrue(hasTag.evaluate(n1)); + assertTrue(hasTag.test(n1)); } @@ -170,9 +156,9 @@ Predicate hasKey = Predicates.hasKey("key"); Node n1 = new Node(); - assertFalse(hasKey.evaluate(n1)); + assertFalse(hasKey.test(n1)); n1.put("Key", "x"); - assertFalse(hasKey.evaluate(n1)); + assertFalse(hasKey.test(n1)); n1.put("key", "x"); - assertTrue(hasKey.evaluate(n1)); + assertTrue(hasKey.test(n1)); } @@ -184,15 +170,15 @@ List list = Arrays.asList("a", "b", "c"); Predicate inCollection = Predicates.inCollection(list); - assertTrue(inCollection.evaluate("a")); - assertTrue(inCollection.evaluate("c")); - assertFalse(inCollection.evaluate("d")); - assertFalse(inCollection.evaluate(null)); + assertTrue(inCollection.test("a")); + assertTrue(inCollection.test("c")); + assertFalse(inCollection.test("d")); + assertFalse(inCollection.test(null)); List list2 = Arrays.asList("a", "b", "c", null); Predicate inCollection2 = Predicates.inCollection(list2); - assertTrue(inCollection2.evaluate("a")); - assertTrue(inCollection2.evaluate("c")); - assertFalse(inCollection2.evaluate("d")); - assertTrue(inCollection2.evaluate(null)); + assertTrue(inCollection2.test("a")); + assertTrue(inCollection2.test("c")); + assertFalse(inCollection2.test("d")); + assertTrue(inCollection2.test(null)); } @@ -203,6 +189,6 @@ public void testIsNull() { Predicate isNull = Predicates.isNull(); - assertTrue(isNull.evaluate(null)); - assertFalse(isNull.evaluate(Integer.valueOf(2))); + assertTrue(isNull.test(null)); + assertFalse(isNull.test(Integer.valueOf(2))); } }