Optimize WorkspaceTreeNode getOrInsert behavior

The flag for-each child matcher now is done via binary search since paths are comparable.

Author: Col-E

gradle/libs.versions.toml

@@ -12,7 +12,7 @@ dex-translator = "1.1.1"
 diffutils = "4.16"
 docking = "0.11.1"
 downgrader = "1.3.3"
-extra-collections = "1.6.0"
+extra-collections = "1.7.0"
 extra-observables = "1.3.0"
 gson = "2.13.1"
 ikonli = "12.4.0"

recaf-core/src/main/java/software/coley/recaf/path/DirectoryPathNode.java

@@ -7,6 +7,7 @@
 import software.coley.recaf.info.FileInfo;
 import software.coley.recaf.workspace.model.bundle.Bundle;
 
+import java.util.Objects;
 import java.util.Set;
 
 /**
@@ -129,4 +130,17 @@ public int localCompare(PathNode<?> o) {
 		}
 		return 0;
 	}
+
+	@Override
+	public boolean equals(Object o) {
+		// If the directories are the same and the parent paths are also equal, then this path points to the same location.
+		if (o instanceof DirectoryPathNode otherPath) {
+			String dir = getValue();
+			String otherDir = otherPath.getValue();
+			return dir.hashCode() == otherDir.hashCode() // Hash check first which is very fast, and the result is cached.
+					&& dir.equals(otherDir) // Sanity check for matching items to prevent hash collisions.
+					&& Objects.equals(getParent(), otherPath.getParent()); // Parents must also match.
+		}
+		return false;
+	}
 }

recaf-core/src/main/java/software/coley/recaf/path/FilePathNode.java

@@ -6,6 +6,7 @@
 import software.coley.recaf.info.FileInfo;
 import software.coley.recaf.workspace.model.bundle.FileBundle;
 
+import java.util.Objects;
 import java.util.Set;
 
 /**
@@ -104,4 +105,17 @@ public int localCompare(PathNode<?> o) {
 		}
 		return 0;
 	}
+
+	@Override
+	public boolean equals(Object o) {
+		// If the file names are the same and the parent paths are also equal, then this path points to the same location.
+		if (o instanceof FilePathNode otherPath) {
+			String name = getValue().getName();
+			String otherName = otherPath.getValue().getName();
+			return name.hashCode() == otherName.hashCode() // Hash check first which is very fast, and the result is cached.
+					&& name.equals(otherName) // Sanity check for matching items to prevent hash collisions.
+					&& Objects.equals(getParent(), otherPath.getParent()); // Parents must also match.
+		}
+		return false;
+	}
 }

recaf-ui/src/main/java/software/coley/recaf/ui/control/tree/FilterableTreeItem.java

@@ -176,7 +176,28 @@ public void addAndSortChild(@Nonnull TreeItem<T> item) {
 	}
 
 	/**
-	 * Add an unfiltered unsorted child to this item.
+	 * Add an unfiltered sorted child to this item.
+	 * It is assumed the index provided will maintain sorted order when used with {@link List#add(int, Object)}.
+	 *
+	 * @param item
+	 * 		Child item to add.
+	 * @param index
+	 * 		Index to add the child at, assumed to maintain sorted order.
+	 */
+	public void addPreSortedChild(@Nonnull TreeItem<T> item, int index) {
+		synchronized (sourceChildren) {
+			if (sourceChildren.isEmpty())
+				sourceChildren.add(item);
+			else
+				sourceChildren.add(index, item);
+			if (item instanceof FilterableTreeItem<?> filterableItem)
+				filterableItem.sourceParent.set(Unchecked.cast(this));
+		}
+	}
+
+	/**
+	 * Add an unfiltered sorted child to this item.
+	 * It is assumed this method is used exclusively and all paths are added in sorted order.
 	 *
 	 * @param item
 	 * 		Child item to add.

recaf-ui/src/main/java/software/coley/recaf/ui/control/tree/WorkspaceTreeNode.java

@@ -10,6 +10,8 @@
 import software.coley.recaf.path.PathNode;
 import software.coley.recaf.util.StringUtil;
 
+import java.util.List;
+
 /**
  * Tree item subtype for more convenience tree building operations.
  *
@@ -201,7 +203,6 @@ public static WorkspaceTreeNode getOrInsertIntoTree(@Nonnull WorkspaceTreeNode n
 	 * @return Inserted node.
 	 */
 	@Nonnull
-	@SuppressWarnings("deprecation")
 	public static WorkspaceTreeNode getOrInsertIntoTree(@Nonnull WorkspaceTreeNode node, @Nonnull PathNode<?> path, boolean sorted) {
 		// Edge case handling for directory nodes.
 		if (path instanceof DirectoryPathNode directoryPath) {
@@ -234,24 +235,17 @@ public static WorkspaceTreeNode getOrInsertIntoTree(@Nonnull WorkspaceTreeNode n
 				DirectoryPathNode localPathNode = directoryPath.withDirectory(directoryName);
 
 				// Get existing tree node, or create child if non-existent
-				WorkspaceTreeNode childNode = null;
-				ObservableList<TreeItem<PathNode<?>>> children;
-				if (node instanceof FilterableTreeItem<?> filterableNode)
-					children = Unchecked.cast(filterableNode.getSourceChildren());
-				else
-					children = node.getChildren();
-				for (TreeItem<PathNode<?>> child : children)
-					if (child.getValue().equals(localPathNode)) {
-						childNode = (WorkspaceTreeNode) child;
-						break;
-					}
-				if (childNode == null) {
+				WorkspaceTreeNode childNode;
+				ObservableList<WorkspaceTreeNode> children = Unchecked.cast(node.getSourceChildren());
+				int index = binaryUnboxingSearch(children, localPathNode);
+				if (index >= 0)
+					childNode = children.get(index);
+				else {
 					childNode = new WorkspaceTreeNode(localPathNode);
-					if (sorted) {
+					if (sorted)
 						node.addPreSortedChild(childNode);
-					} else {
-						node.addAndSortChild(childNode);
-					}
+					else
+						node.addPreSortedChild(childNode, -(index + 1));
 				}
 
 				// Prepare for next directory path entry.
@@ -272,22 +266,39 @@ else if (path.typeIdMatch(node.getValue())) {
 		}
 
 		// Check if already inserted.
-		ObservableList<TreeItem<PathNode<?>>> children;
-		if (node instanceof FilterableTreeItem<?> filterableNode)
-			children = Unchecked.cast(filterableNode.getSourceChildren());
-		else
-			children = node.getChildren();
-		for (TreeItem<PathNode<?>> child : children)
-			if (path.equals(child.getValue()))
-				return (WorkspaceTreeNode) child;
+		ObservableList<WorkspaceTreeNode> children = Unchecked.cast(node.getSourceChildren());
+		WorkspaceTreeNode inserted;//= new WorkspaceTreeNode(path);
+		int index = binaryUnboxingSearch(children, path);
+		if (index >= 0)
+			return children.get(index);
+		inserted = new WorkspaceTreeNode(path);
 
 		// Not already inserted, create a new node and insert it.
-		WorkspaceTreeNode inserted = new WorkspaceTreeNode(path);
-		if (sorted) {
+		if (sorted)
 			node.addPreSortedChild(inserted);
-		} else {
-			node.addAndSortChild(inserted);
-		}
+		else
+			node.addPreSortedChild(inserted, -(index + 1));
+
 		return inserted;
 	}
+
+	/**
+	 * Binary search but using {@link PathNode#localCompare(software.coley.recaf.path.PathNode)}
+	 * rather than the standard {@link java.lang.Comparable#compareTo(java.lang.Object)}.
+	 */
+	private static int binaryUnboxingSearch(@Nonnull List<WorkspaceTreeNode> items, @Nonnull PathNode<?> target) {
+		int first = 0;
+		int last = items.size() - 1;
+		while (first <= last) {
+			int middle = (first + last) >>> 1;
+			int compResult = items.get(middle).getValue().localCompare(target);
+			if (compResult < 0)
+				first = middle + 1;
+			else if (compResult > 0)
+				last = middle - 1;
+			else
+				return middle;
+		}
+		return -(first + 1);
+	}
 }