Expose equate() on filtered types so...

... Their rules can be reused.

src/main/java/com/github/tommyettinger/ds/FilteredIterableMap.java

@@ -243,8 +243,18 @@ protected int place (Object item) {
 		return super.place(item);
 	}
 
+	/**
+	 * Compares two objects for equality by the rules this filtered data structure uses for keys.
+	 * This will return true if the arguments are reference-equivalent or both null. Otherwise, it
+	 * requires that both are {@link Iterable}s and compares them using the {@link #getFilter() filter}
+	 * and {@link #getEditor() editor} of this object.
+	 *
+	 * @param left  must be non-null; typically a key being compared, but not necessarily
+	 * @param right may be null; typically a key being compared, but can often be null for an empty key slot, or some other type
+	 * @return true if left and right are equivalent according to the rules this filtered type uses
+	 */
 	@Override
-	protected boolean equate (Object left, @Nullable Object right) {
+	public boolean equate (Object left, @Nullable Object right) {
 		if (left == right)
 			return true;
 		if(right == null) return false;

src/main/java/com/github/tommyettinger/ds/FilteredIterableOrderedMap.java

@@ -252,8 +252,18 @@ protected int place (Object item) {
 		return super.place(item);
 	}
 
+	/**
+	 * Compares two objects for equality by the rules this filtered data structure uses for keys.
+	 * This will return true if the arguments are reference-equivalent or both null. Otherwise, it
+	 * requires that both are {@link Iterable}s and compares them using the {@link #getFilter() filter}
+	 * and {@link #getEditor() editor} of this object.
+	 *
+	 * @param left  must be non-null; typically a key being compared, but not necessarily
+	 * @param right may be null; typically a key being compared, but can often be null for an empty key slot, or some other type
+	 * @return true if left and right are equivalent according to the rules this filtered type uses
+	 */
 	@Override
-	protected boolean equate (Object left, @Nullable Object right) {
+	public boolean equate (Object left, @Nullable Object right) {
 		if (left == right)
 			return true;
 		if(right == null) return false;

src/main/java/com/github/tommyettinger/ds/FilteredIterableOrderedSet.java

@@ -252,8 +252,18 @@ protected int place (Object item) {
 		return super.place(item);
 	}
 
+	/**
+	 * Compares two objects for equality by the rules this filtered data structure uses for keys.
+	 * This will return true if the arguments are reference-equivalent or both null. Otherwise, it
+	 * requires that both are {@link Iterable}s and compares them using the {@link #getFilter() filter}
+	 * and {@link #getEditor() editor} of this object.
+	 *
+	 * @param left  must be non-null; typically a key being compared, but not necessarily
+	 * @param right may be null; typically a key being compared, but can often be null for an empty key slot, or some other type
+	 * @return true if left and right are equivalent according to the rules this filtered type uses
+	 */
 	@Override
-	protected boolean equate (Object left, @Nullable Object right) {
+	public boolean equate (Object left, @Nullable Object right) {
 		if (left == right)
 			return true;
 		if(right == null) return false;

src/main/java/com/github/tommyettinger/ds/FilteredIterableSet.java

@@ -239,8 +239,18 @@ protected int place (Object item) {
 		return super.place(item);
 	}
 
+	/**
+	 * Compares two objects for equality by the rules this filtered data structure uses for keys.
+	 * This will return true if the arguments are reference-equivalent or both null. Otherwise, it
+	 * requires that both are {@link Iterable}s and compares them using the {@link #getFilter() filter}
+	 * and {@link #getEditor() editor} of this object.
+	 *
+	 * @param left  must be non-null; typically a key being compared, but not necessarily
+	 * @param right may be null; typically a key being compared, but can often be null for an empty key slot, or some other type
+	 * @return true if left and right are equivalent according to the rules this filtered type uses
+	 */
 	@Override
-	protected boolean equate (Object left, @Nullable Object right) {
+	public boolean equate (Object left, @Nullable Object right) {
 		if (left == right)
 			return true;
 		if(right == null) return false;

src/main/java/com/github/tommyettinger/ds/FilteredStringMap.java

@@ -240,9 +240,18 @@ protected int place (Object item) {
 		}
 		return super.place(item);
 	}
-
+	/**
+	 * Compares two objects for equality by the rules this filtered data structure uses for keys.
+	 * This will return true if the arguments are reference-equivalent or both null. Otherwise, it
+	 * requires that both are {@link String}s and compares them using the {@link #getFilter() filter}
+	 * and {@link #getEditor() editor} of this object.
+	 *
+	 * @param left  must be non-null; typically a key being compared, but not necessarily
+	 * @param right may be null; typically a key being compared, but can often be null for an empty key slot, or some other type
+	 * @return true if left and right are equivalent according to the rules this filtered type uses
+	 */
 	@Override
-	protected boolean equate (Object left, @Nullable Object right) {
+	public boolean equate (Object left, @Nullable Object right) {
 		if (left == right)
 			return true;
 		if (right == null)

src/main/java/com/github/tommyettinger/ds/FilteredStringOrderedMap.java

@@ -265,8 +265,18 @@ protected int place (Object item) {
 		return super.place(item);
 	}
 
+	/**
+	 * Compares two objects for equality by the rules this filtered data structure uses for keys.
+	 * This will return true if the arguments are reference-equivalent or both null. Otherwise, it
+	 * requires that both are {@link String}s and compares them using the {@link #getFilter() filter}
+	 * and {@link #getEditor() editor} of this object.
+	 *
+	 * @param left  must be non-null; typically a key being compared, but not necessarily
+	 * @param right may be null; typically a key being compared, but can often be null for an empty key slot, or some other type
+	 * @return true if left and right are equivalent according to the rules this filtered type uses
+	 */
 	@Override
-	protected boolean equate (Object left, @Nullable Object right) {
+	public boolean equate (Object left, @Nullable Object right) {
 		if (left == right)
 			return true;
 		if (right == null)

src/main/java/com/github/tommyettinger/ds/FilteredStringOrderedSet.java

@@ -254,8 +254,18 @@ protected int place (Object item) {
 		return super.place(item);
 	}
 
+	/**
+	 * Compares two objects for equality by the rules this filtered data structure uses for keys.
+	 * This will return true if the arguments are reference-equivalent or both null. Otherwise, it
+	 * requires that both are {@link String}s and compares them using the {@link #getFilter() filter}
+	 * and {@link #getEditor() editor} of this object.
+	 *
+	 * @param left  must be non-null; typically a key being compared, but not necessarily
+	 * @param right may be null; typically a key being compared, but can often be null for an empty key slot, or some other type
+	 * @return true if left and right are equivalent according to the rules this filtered type uses
+	 */
 	@Override
-	protected boolean equate (Object left, @Nullable Object right) {
+	public boolean equate (Object left, @Nullable Object right) {
 		if (left == right)
 			return true;
 		if(right == null) return false;

src/main/java/com/github/tommyettinger/ds/FilteredStringSet.java

@@ -230,8 +230,19 @@ protected int place (Object item) {
 		return super.place(item);
 	}
 
+	/**
+	 * Compares two objects for equality by the rules this filtered data structure uses for keys.
+	 * This will return true if the arguments are reference-equivalent or both null. Otherwise, it
+	 * requires that both are {@link String}s and compares them using the {@link #getFilter() filter}
+	 * and {@link #getEditor() editor} of this object.
+	 *
+	 * @param left  must be non-null; typically a key being compared, but not necessarily
+	 * @param right may be null; typically a key being compared, but can often be null for an empty key slot, or some other type
+	 * @return true if left and right are equivalent according to the rules this filtered type uses
+	 */
 	@Override
-	protected boolean equate (Object left, @Nullable Object right) {
+	public boolean equate (Object left, @Nullable Object right) {
+
 		if (left == right)
 			return true;
 		if(right == null) return false;

src/test/java/com/github/tommyettinger/ds/test/CaseInsensitiveTest.java

@@ -68,11 +68,11 @@ public void testOrderedMap () {
 			Assert.assertEquals(ent.getKey(), ent.getValue());
 		}
 		FilteredStringOrderedMap<String> fil = new FilteredStringOrderedMap<>(Character::isLetter, Character::toUpperCase,
-			new String[]{"foo", "bar", "baz"},
+			new String[]{"foo42", "bar666", "baz9001"},
 			new String[]{"foo", "bar", "baz"}
 		);
 		for(Map.Entry<String, String> ent : fil){
-			Assert.assertEquals(ent.getKey(), ent.getValue());
+			Assert.assertTrue(fil.equate(ent.getKey(), ent.getValue()));
 		}
 		CaseInsensitiveOrderedMap<ObjectList<String>> synonyms = CaseInsensitiveOrderedMap.with(
 			"intelligence", ObjectList.with("cunning", "acumen", "wits", "wisdom", "intellect"),

src/test/java/com/github/tommyettinger/ds/test/FilteredTest.java

@@ -17,7 +17,9 @@
 
 package com.github.tommyettinger.ds.test;
 
+import com.github.tommyettinger.ds.FilteredIterableMap;
 import com.github.tommyettinger.ds.FilteredIterableSet;
+import com.github.tommyettinger.ds.ObjectDeque;
 import com.github.tommyettinger.ds.ObjectList;
 import org.junit.Assert;
 import org.junit.Test;
@@ -26,12 +28,47 @@ public class FilteredTest {
 	@Test
 	public void testIterableSet() {
 		FilteredIterableSet<String, Iterable<String>> fil = FilteredIterableSet.with(
+			(String s) -> s.length() > 3, String::toUpperCase,
+			ObjectList.with("zzz", "bee", "binturong"),
+			ObjectDeque.with("hm?", "bee", "BINTURONG"),
+			ObjectList.with(":D", "bee", "Aardvark", "bandicoot")
+			);
+		Assert.assertEquals(2, fil.size());
+	}
+
+	/**
+	 * This is a little odd... the key isn't updated but the value is... The keys are considered equivalent, though.
+	 */
+	@Test
+	public void testIterableMap() {
+		FilteredIterableMap<String, Iterable<String>, Integer> fil = FilteredIterableMap.with(
+			(String s) -> s.length() > 3, String::toUpperCase,
+			ObjectList.with("zzz", "bee", "binturong"), -1,
+			ObjectDeque.with("hm?", "bee", "BINTURONG"), 1,
+			ObjectList.with(":D", "bee", "Aardvark", "bandicoot"), 2
+			);
+		System.out.println(fil);
+		Assert.assertEquals(2, fil.size());
+	}
+	@Test
+	public void testIterableSetSubtype() {
+		FilteredIterableSet<String, ObjectList<String>> fil = FilteredIterableSet.with(
 			(String s) -> s.length() > 3, String::toUpperCase,
 			ObjectList.with("zzz", "bee", "binturong"),
 			ObjectList.with("hm?", "bee", "BINTURONG"),
 			ObjectList.with(":D", "bee", "Aardvark", "bandicoot")
 			);
-//		System.out.println(fil);
+		Assert.assertEquals(2, fil.size());
+	}
+	@Test
+	public void testIterableMapSubtype() {
+		FilteredIterableMap<String, ObjectList<String>, Integer> fil = FilteredIterableMap.with(
+			(String s) -> s.length() > 3, String::toUpperCase,
+			ObjectList.with("zzz", "bee", "binturong"), -1,
+			ObjectList.with("hm?", "bee", "BINTURONG"), 1,
+			ObjectList.with(":D", "bee", "Aardvark", "bandicoot"), 2
+		);
+		System.out.println(fil);
 		Assert.assertEquals(2, fil.size());
 	}
 }