From 549034500a55ffc8f401fd73a74d8dc55f096d2f Mon Sep 17 00:00:00 2001
From: Robin Rosenberg <robin.rosenberg@dewire.com>
Date: Mon, 31 Dec 2012 19:17:19 +0100
Subject: [PATCH 1/2] Speed up handling of "only" paths in the CommitCommand

Use binary search to reduce the number of lookups for very large number
of paths.

Change-Id: I76a16594b756bffd95298897414485a9cd637819
---
 .../org/eclipse/jgit/api/CommitCommand.java   | 23 +++++++++----------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java b/org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java
index f51b301cd..056b47d0f 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java
@@ -46,6 +46,7 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.text.MessageFormat;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 
@@ -147,6 +148,7 @@ public class CommitCommand extends GitCommand<RevCommit> {
 			ConcurrentRefUpdateException,
 			WrongRepositoryStateException {
 		checkCallable();
+		Collections.sort(only);
 
 		RepositoryState state = repo.getRepositoryState();
 		if (!state.canCommit())
@@ -452,18 +454,15 @@ public class CommitCommand extends GitCommand<RevCommit> {
 	 * @return the item's index in <code>only</code>; -1 if no item matches
 	 */
 	private int lookupOnly(String pathString) {
-		int i = 0;
-		for (String o : only) {
-			String p = pathString;
-			while (true) {
-				if (p.equals(o))
-					return i;
-				int l = p.lastIndexOf("/"); //$NON-NLS-1$
-				if (l < 1)
-					break;
-				p = p.substring(0, l);
-			}
-			i++;
+		String p = pathString;
+		while (true) {
+			int position = Collections.binarySearch(only, p);
+			if (position >= 0)
+				return position;
+			int l = p.lastIndexOf("/"); //$NON-NLS-1$
+			if (l < 1)
+				break;
+			p = p.substring(0, l);
 		}
 		return -1;
 	}

From 576e5acdd054e2dcd8cde3fe4d822bc3609850c1 Mon Sep 17 00:00:00 2001
From: Robin Rosenberg <robin.rosenberg@dewire.com>
Date: Tue, 1 Jan 2013 15:06:07 +0100
Subject: [PATCH 2/2] Speed up PathFilterGroup.include for large set of paths

This requires that we internally sort all paths so content of
directories follow the directory immediately.

Bug: 397185
Change-Id: I3e9735c7bdd99437929da8f9c9d4960a1273054b
---
 .../jgit/treewalk/filter/PathFilterGroup.java | 70 +++++++++++++++----
 1 file changed, 55 insertions(+), 15 deletions(-)

diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathFilterGroup.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathFilterGroup.java
index 51761a812..d4b0555cd 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathFilterGroup.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathFilterGroup.java
@@ -177,33 +177,73 @@ public class PathFilterGroup {
 	}
 
 	static class Group extends TreeFilter {
-		private static final Comparator<PathFilter> PATH_SORT = new Comparator<PathFilter>() {
+		private static int pathPrefixSortCompare(byte[] p1, byte[] p2,
+				boolean justMatch) {
+			int ci = 0;
+			while (ci < p1.length && ci < p2.length) {
+				int c1 = p1[ci];
+				int c2 = p2[ci];
+				if (c1 == '/')
+					c1 = 0;
+				if (c2 == '/')
+					c2 = 0;
+				int cmp = c1 - c2;
+				if (cmp != 0)
+					return cmp;
+				++ci;
+			}
+			if (ci < p1.length) {
+				int c1 = p1[ci];
+				if (c1 == '/')
+					if (justMatch)
+						return 0;
+				return 1;
+			}
+			if (ci < p2.length) {
+				int c2 = p2[ci];
+				if (c2 == '/')
+					return 0;
+				return -1;
+			}
+			return 0;
+		}
+
+		private static final Comparator<PathFilter> PATH_PREFIX_SORT = new Comparator<PathFilter>() {
 			public int compare(final PathFilter o1, final PathFilter o2) {
-				return o1.pathStr.compareTo(o2.pathStr);
+				return pathPrefixSortCompare(o1.pathRaw, o2.pathRaw, false);
 			}
+
 		};
 
 		private final PathFilter[] paths;
 
 		private Group(final PathFilter[] p) {
 			paths = p;
-			Arrays.sort(paths, PATH_SORT);
+			Arrays.sort(paths, PATH_PREFIX_SORT);
 		}
 
 		@Override
 		public boolean include(final TreeWalk walker) {
-			final int n = paths.length;
-			for (int i = 0;;) {
-				final byte[] r = paths[i].pathRaw;
-				final int cmp = walker.isPathPrefix(r, r.length);
-				if (cmp == 0)
-					return true;
-				if (++i < n)
-					continue;
-				if (cmp > 0)
-					throw StopWalkException.INSTANCE;
-				return false;
-			}
+			final byte[] rawPath = walker.getRawPath();
+			Comparator comparator = new Comparator<Object>() {
+				public int compare(Object pf, Object raw) {
+					PathFilter pathFilter = (PathFilter) pf;
+					int ret = -pathPrefixSortCompare(walker.getRawPath(),
+							pathFilter.pathRaw, true);
+					return ret;
+				}
+			};
+
+			Object[] pathsObject = paths;
+			Object rawObject = rawPath;
+			@SuppressWarnings("unchecked")
+			int position = Arrays.binarySearch(pathsObject, rawObject,
+					comparator);
+			if (position >= 0)
+				return true;
+			if (position == -paths.length - 1)
+				throw StopWalkException.INSTANCE;
+			return false;
 		}
 
 		@Override