[EGIT PATCH 00/26] New DirCache API

classic Classic list List threaded Threaded
26 messages Options
12
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 00/26] New DirCache API

Shawn Pearce
This is (finally) my long-promised DirCache API.  It has been evolving
and growing since before April I think.  Its finally cleaned up enough
for public viewing and usage.

I started this change because I didn't see an easy way to plug
GitIndex into TreeWalk, I found GitIndex to be too slow, and it
required direct access to the working directory in order to handle
certain operations.  DirCache has none of these issues.

The API is meant to replace GitIndex, as we can now merge-sort a 'DIRC'
(aka .git/index) file against any other tree as part of any active
TreeWalk instance.  This makes it really easy to do n-way diffs against
commits, one or more index files, and the working directory.

The implementation is leaner and meaner than GitIndex.  It avoids a
lot of unnecessary conversion overheads, and it tries to reduce the
per-entry memory usage as much as possible.

We almost support the 'TREE' cache extension.  Updates to the index
through DirCacheBuilder or DirCacheEditor wind up throwing away the
entire 'TREE' extension, instead of invalidating only those trees
we know to be dirty.  This is certainly suboptimal and is an area
for future improvement.

From here I'm going to start building 3 way merge support onto
this API, by taking advantage of TreeWalk to do the parallel
tree unpacks necessary for the merge operation.

Yes, its ~4.5k lines (excluding some test vectors).  However it
will allow us to eventually remove about 2k lines from jgit alone:

  AbstractIndexTreeVisitor  74
  GitIndex                 912
  IndexDiff                160
  IndexTreeWalker          241
  IndexTreeVisitor          97
  TreeIterator             203
  WorkDirCheckout          401
  ----------------------------
                          2088

Other classes like GitResourceDecorator simplify I think as a result
of this new API being available.  I have only started to port that
over, but found I was getting side-tracked in porting the existing
GitIndex users and I really want to focus on the merge code instead.

So overall we may see about a 2k line increase as a result of this
API being used in the tree rather than GitIndex, but since it fits
into the overall TreeWalk architecture its better suited for reuse,
so we may see more than 2k saved over time.


Shawn O. Pearce (26):
  Force all source code to UTF-8 encoding by default
  Protect WorkingTreeIterator's name encoding from weird ByteBuffers
  Add Constants.encode as a utility for quick encoding in UTF-8
  Rely upon Constants.CHARSET over Constants.CHARACTER_ENCODING
  Allow AbstractTreeIterators to find out about StopWalkExceptions
  Implement a new .git/index (aka dircache) read interface
  Export the new DirCache API to Eclipse plugins using jgit
  Support locking (and unlocking) a .git/index through DirCache
  Support writing a .git/index through DirCache
  Support the 'TREE' extension in .git/index through DirCache
  Support using a DirCache within a TreeWalk
  Support recreating a .git/index through DirCache
  Support iterating and building a DirCache at the same time
  Support creating a new DirCacheEntry for an arbitrary path
  Support a simplified model of editing index entries
  Support recursively getting all entries under a subtree path
  Support copying meta fields from one DirCacheEntry to another
  Add JUnit tests for new DirCache API
  Add JUnit tests for DirCache compatibility with C Git
  Allow the new DirCacheIterator in command line arguments
  Add debugging commands to interact with the new DirCache code
  Add a basic command line implementation of rm
  Rewrite GitMoveDeleteHook to use DirCacheBuilder
  Teach GitMoveDeleteHook how to move a folder recursively
  Rewrite UntrackOperation to use DirCacheBuilder
  Rewrite AssumeUnchangedOperation to use DirCache

 .../.settings/org.eclipse.core.resources.prefs     |    3 +
 .../.settings/org.eclipse.core.resources.prefs     |    3 +
 .../.settings/org.eclipse.core.resources.prefs     |    3 +
 .../.settings/org.eclipse.core.resources.prefs     |    3 +
 .../org/spearce/egit/core/GitMoveDeleteHook.java   |  156 ++-
 .../egit/core/op/AssumeUnchangedOperation.java     |  133 +-
 .../org/spearce/egit/core/op/UntrackOperation.java |   98 +-
 .../.settings/org.eclipse.core.resources.prefs     |    3 +
 .../.settings/org.eclipse.core.resources.prefs     |    3 +
 .../.settings/org.eclipse.core.resources.prefs     |    3 +
 .../services/org.spearce.jgit.pgm.TextBuiltin      |    6 +
 .../src/org/spearce/jgit/pgm/Rm.java               |   92 ++
 .../org/spearce/jgit/pgm/debug/MakeCacheTree.java  |   67 +
 .../org/spearce/jgit/pgm/debug/ReadDirCache.java   |   53 +
 .../org/spearce/jgit/pgm/debug/ShowCacheTree.java  |   69 +
 .../org/spearce/jgit/pgm/debug/ShowDirCache.java   |   72 +
 .../org/spearce/jgit/pgm/debug/WriteDirCache.java  |   54 +
 .../jgit/pgm/opt/AbstractTreeIteratorHandler.java  |   13 +
 .../.settings/org.eclipse.core.resources.prefs     |    3 +
 .../spearce/jgit/dircache/DirCacheBasicTest.java   |  185 +++
 .../jgit/dircache/DirCacheBuilderIteratorTest.java |   91 ++
 .../spearce/jgit/dircache/DirCacheBuilderTest.java |  253 ++++
 .../dircache/DirCacheCGitCompatabilityTest.java    |  204 +++
 .../spearce/jgit/dircache/DirCacheFindTest.java    |   86 ++
 .../jgit/dircache/DirCacheIteratorTest.java        |  273 ++++
 .../spearce/jgit/dircache/DirCacheTreeTest.java    |  150 ++
 .../tst/org/spearce/jgit/dircache/gitgit.index     |  Bin 0 -> 134799 bytes
 .../tst/org/spearce/jgit/dircache/gitgit.lsfiles   | 1437 ++++++++++++++++++++
 .../tst/org/spearce/jgit/dircache/gitgit.lstree    |  331 +++++
 .../spearce/jgit/lib/ConstantsEncodingTest.java    |   89 ++
 .../.settings/org.eclipse.core.resources.prefs     |    3 +
 org.spearce.jgit/META-INF/MANIFEST.MF              |    3 +-
 .../spearce/jgit/dircache/BaseDirCacheEditor.java  |  194 +++
 .../src/org/spearce/jgit/dircache/DirCache.java    |  681 +++++++++
 .../jgit/dircache/DirCacheBuildIterator.java       |  124 ++
 .../org/spearce/jgit/dircache/DirCacheBuilder.java |  175 +++
 .../org/spearce/jgit/dircache/DirCacheEditor.java  |  265 ++++
 .../org/spearce/jgit/dircache/DirCacheEntry.java   |  385 ++++++
 .../spearce/jgit/dircache/DirCacheIterator.java    |  205 +++
 .../org/spearce/jgit/dircache/DirCacheTree.java    |  453 ++++++
 .../src/org/spearce/jgit/lib/Constants.java        |   25 +
 .../src/org/spearce/jgit/lib/ObjectWriter.java     |    2 +-
 .../src/org/spearce/jgit/lib/RefDatabase.java      |    9 +-
 .../src/org/spearce/jgit/lib/RepositoryConfig.java |    4 +-
 .../org/spearce/jgit/transport/PacketLineIn.java   |    3 +-
 .../jgit/transport/SideBandInputStream.java        |    3 +-
 .../spearce/jgit/transport/TransportBundle.java    |    3 +-
 .../spearce/jgit/transport/WalkPushConnection.java |    4 +-
 .../jgit/transport/WalkRemoteObjectDatabase.java   |    5 +-
 .../jgit/treewalk/AbstractTreeIterator.java        |   11 +
 .../spearce/jgit/treewalk/EmptyTreeIterator.java   |    6 +
 .../src/org/spearce/jgit/treewalk/TreeWalk.java    |   12 +-
 .../spearce/jgit/treewalk/WorkingTreeIterator.java |    2 +-
 .../spearce/jgit/treewalk/filter/PathFilter.java   |   10 +-
 54 files changed, 6333 insertions(+), 190 deletions(-)
 create mode 100644 org.spearce.egit-feature/.settings/org.eclipse.core.resources.prefs
 create mode 100644 org.spearce.egit-updatesite/.settings/org.eclipse.core.resources.prefs
 create mode 100644 org.spearce.egit.core.test/.settings/org.eclipse.core.resources.prefs
 create mode 100644 org.spearce.egit.core/.settings/org.eclipse.core.resources.prefs
 create mode 100644 org.spearce.egit.ui/.settings/org.eclipse.core.resources.prefs
 create mode 100644 org.spearce.egit/.settings/org.eclipse.core.resources.prefs
 create mode 100644 org.spearce.jgit.pgm/.settings/org.eclipse.core.resources.prefs
 create mode 100644 org.spearce.jgit.pgm/src/org/spearce/jgit/pgm/Rm.java
 create mode 100644 org.spearce.jgit.pgm/src/org/spearce/jgit/pgm/debug/MakeCacheTree.java
 create mode 100644 org.spearce.jgit.pgm/src/org/spearce/jgit/pgm/debug/ReadDirCache.java
 create mode 100644 org.spearce.jgit.pgm/src/org/spearce/jgit/pgm/debug/ShowCacheTree.java
 create mode 100644 org.spearce.jgit.pgm/src/org/spearce/jgit/pgm/debug/ShowDirCache.java
 create mode 100644 org.spearce.jgit.pgm/src/org/spearce/jgit/pgm/debug/WriteDirCache.java
 create mode 100644 org.spearce.jgit.test/.settings/org.eclipse.core.resources.prefs
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheBasicTest.java
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheBuilderIteratorTest.java
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheBuilderTest.java
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheCGitCompatabilityTest.java
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheFindTest.java
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheIteratorTest.java
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheTreeTest.java
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/dircache/gitgit.index
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/dircache/gitgit.lsfiles
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/dircache/gitgit.lstree
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/lib/ConstantsEncodingTest.java
 create mode 100644 org.spearce.jgit/.settings/org.eclipse.core.resources.prefs
 create mode 100644 org.spearce.jgit/src/org/spearce/jgit/dircache/BaseDirCacheEditor.java
 create mode 100644 org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
 create mode 100644 org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheBuildIterator.java
 create mode 100644 org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheBuilder.java
 create mode 100644 org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEditor.java
 create mode 100644 org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEntry.java
 create mode 100644 org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheIterator.java
 create mode 100644 org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheTree.java

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 01/26] Force all source code to UTF-8 encoding by default

Shawn Pearce
To keep things simple we should use a single character encoding
for all of our source files, and UTF-8 is the best choice as it
will handle any possible Unicode character but the majority of
our source is plain 'ole ASCII.

We really want to support full Unicode in our sources so we can
setup Unicode test vectors, have translations which are usually
in the standard encoding, and correctly support author names in
source code copyright comments.

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../.settings/org.eclipse.core.resources.prefs     |    3 +++
 .../.settings/org.eclipse.core.resources.prefs     |    3 +++
 .../.settings/org.eclipse.core.resources.prefs     |    3 +++
 .../.settings/org.eclipse.core.resources.prefs     |    3 +++
 .../.settings/org.eclipse.core.resources.prefs     |    3 +++
 .../.settings/org.eclipse.core.resources.prefs     |    3 +++
 .../.settings/org.eclipse.core.resources.prefs     |    3 +++
 .../.settings/org.eclipse.core.resources.prefs     |    3 +++
 .../.settings/org.eclipse.core.resources.prefs     |    3 +++
 9 files changed, 27 insertions(+), 0 deletions(-)
 create mode 100644 org.spearce.egit-feature/.settings/org.eclipse.core.resources.prefs
 create mode 100644 org.spearce.egit-updatesite/.settings/org.eclipse.core.resources.prefs
 create mode 100644 org.spearce.egit.core.test/.settings/org.eclipse.core.resources.prefs
 create mode 100644 org.spearce.egit.core/.settings/org.eclipse.core.resources.prefs
 create mode 100644 org.spearce.egit.ui/.settings/org.eclipse.core.resources.prefs
 create mode 100644 org.spearce.egit/.settings/org.eclipse.core.resources.prefs
 create mode 100644 org.spearce.jgit.pgm/.settings/org.eclipse.core.resources.prefs
 create mode 100644 org.spearce.jgit.test/.settings/org.eclipse.core.resources.prefs
 create mode 100644 org.spearce.jgit/.settings/org.eclipse.core.resources.prefs

diff --git a/org.spearce.egit-feature/.settings/org.eclipse.core.resources.prefs b/org.spearce.egit-feature/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..8d266d9
--- /dev/null
+++ b/org.spearce.egit-feature/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,3 @@
+#Mon Aug 11 16:46:45 PDT 2008
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
diff --git a/org.spearce.egit-updatesite/.settings/org.eclipse.core.resources.prefs b/org.spearce.egit-updatesite/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..4ec836b
--- /dev/null
+++ b/org.spearce.egit-updatesite/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,3 @@
+#Mon Aug 11 16:46:54 PDT 2008
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
diff --git a/org.spearce.egit.core.test/.settings/org.eclipse.core.resources.prefs b/org.spearce.egit.core.test/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..84e44d8
--- /dev/null
+++ b/org.spearce.egit.core.test/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,3 @@
+#Mon Aug 11 16:47:12 PDT 2008
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
diff --git a/org.spearce.egit.core/.settings/org.eclipse.core.resources.prefs b/org.spearce.egit.core/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..d4ff695
--- /dev/null
+++ b/org.spearce.egit.core/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,3 @@
+#Mon Aug 11 16:47:03 PDT 2008
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
diff --git a/org.spearce.egit.ui/.settings/org.eclipse.core.resources.prefs b/org.spearce.egit.ui/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..2f242b3
--- /dev/null
+++ b/org.spearce.egit.ui/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,3 @@
+#Mon Aug 11 16:47:19 PDT 2008
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
diff --git a/org.spearce.egit/.settings/org.eclipse.core.resources.prefs b/org.spearce.egit/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..78f271d
--- /dev/null
+++ b/org.spearce.egit/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,3 @@
+#Mon Aug 11 16:46:35 PDT 2008
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
diff --git a/org.spearce.jgit.pgm/.settings/org.eclipse.core.resources.prefs b/org.spearce.jgit.pgm/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..759548b
--- /dev/null
+++ b/org.spearce.jgit.pgm/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,3 @@
+#Mon Aug 11 16:46:23 PDT 2008
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
diff --git a/org.spearce.jgit.test/.settings/org.eclipse.core.resources.prefs b/org.spearce.jgit.test/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..a2724ba
--- /dev/null
+++ b/org.spearce.jgit.test/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,3 @@
+#Mon Aug 11 16:05:15 PDT 2008
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
diff --git a/org.spearce.jgit/.settings/org.eclipse.core.resources.prefs b/org.spearce.jgit/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..66ac15c
--- /dev/null
+++ b/org.spearce.jgit/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,3 @@
+#Mon Aug 11 16:46:12 PDT 2008
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 02/26] Protect WorkingTreeIterator's name encoding from weird ByteBuffers

Shawn Pearce
If a ByteBuffer decides to be cute and give us an array but use
an array offset that isn't zero we cannot use its array as our
own encodedName array.  Instead we must create a copy of the array
so we can safely assume where the path starts.

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../spearce/jgit/treewalk/WorkingTreeIterator.java |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

diff --git a/org.spearce.jgit/src/org/spearce/jgit/treewalk/WorkingTreeIterator.java b/org.spearce.jgit/src/org/spearce/jgit/treewalk/WorkingTreeIterator.java
index 4ac711b..356222b 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/treewalk/WorkingTreeIterator.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/treewalk/WorkingTreeIterator.java
@@ -415,7 +415,7 @@ public abstract class WorkingTreeIterator extends AbstractTreeIterator {
  throws CharacterCodingException {
  final ByteBuffer b = enc.encode(CharBuffer.wrap(getName()));
  encodedNameLen = b.limit();
- if (b.hasArray())
+ if (b.hasArray() && b.arrayOffset() == 0)
  encodedName = b.array();
  else
  b.get(encodedName = new byte[encodedNameLen]);
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 03/26] Add Constants.encode as a utility for quick encoding in UTF-8

Shawn Pearce
We often need to convert a string into a UTF-8 encoding, so that
we can use this string as a path filter in a TreeWalk or in some
other suitable place where we assume a standard UTF-8 encoding is
being used.  As we have already done the lookup for the CHARSET
we can reuse that same CHARSET reference during future encoding
calls, while allowing the CharSet implementation to cache and
reuse the actual encoder instance.

Whenever possible we try to avoid copying the result as most of
the time the returned ByteBuffer's internal array matches the
result array we need to return to our caller.

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../spearce/jgit/lib/ConstantsEncodingTest.java    |   89 ++++++++++++++++++++
 .../src/org/spearce/jgit/lib/Constants.java        |   25 ++++++
 2 files changed, 114 insertions(+), 0 deletions(-)
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/lib/ConstantsEncodingTest.java

diff --git a/org.spearce.jgit.test/tst/org/spearce/jgit/lib/ConstantsEncodingTest.java b/org.spearce.jgit.test/tst/org/spearce/jgit/lib/ConstantsEncodingTest.java
new file mode 100644
index 0000000..7b3e5a0
--- /dev/null
+++ b/org.spearce.jgit.test/tst/org/spearce/jgit/lib/ConstantsEncodingTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2008, Google Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.lib;
+
+import java.io.UnsupportedEncodingException;
+import java.util.Arrays;
+
+import junit.framework.TestCase;
+
+public class ConstantsEncodingTest extends TestCase {
+ public void testEncodeASCII_SimpleASCII()
+ throws UnsupportedEncodingException {
+ final String src = "abc";
+ final byte[] exp = { 'a', 'b', 'c' };
+ final byte[] res = Constants.encodeASCII(src);
+ assertTrue(Arrays.equals(exp, res));
+ assertEquals(src, new String(res, 0, res.length, "UTF-8"));
+ }
+
+ public void testEncodeASCII_FailOnNonASCII() {
+ final String src = "Ūnĭcōde̽";
+ try {
+ Constants.encodeASCII(src);
+ fail("Incorrectly accepted a Unicode character");
+ } catch (IllegalArgumentException err) {
+ assertEquals("Not ASCII string: " + src, err.getMessage());
+ }
+ }
+
+ public void testEncodeASCII_Number13() {
+ final long src = 13;
+ final byte[] exp = { '1', '3' };
+ final byte[] res = Constants.encodeASCII(src);
+ assertTrue(Arrays.equals(exp, res));
+ }
+
+ public void testEncode_SimpleASCII() throws UnsupportedEncodingException {
+ final String src = "abc";
+ final byte[] exp = { 'a', 'b', 'c' };
+ final byte[] res = Constants.encode(src);
+ assertTrue(Arrays.equals(exp, res));
+ assertEquals(src, new String(res, 0, res.length, "UTF-8"));
+ }
+
+ public void testEncode_Unicode() throws UnsupportedEncodingException {
+ final String src = "Ūnĭcōde̽";
+ final byte[] exp = { (byte) 0xC5, (byte) 0xAA, 0x6E, (byte) 0xC4,
+ (byte) 0xAD, 0x63, (byte) 0xC5, (byte) 0x8D, 0x64, 0x65,
+ (byte) 0xCC, (byte) 0xBD };
+ final byte[] res = Constants.encode(src);
+ assertTrue(Arrays.equals(exp, res));
+ assertEquals(src, new String(res, 0, res.length, "UTF-8"));
+ }
+}
diff --git a/org.spearce.jgit/src/org/spearce/jgit/lib/Constants.java b/org.spearce.jgit/src/org/spearce/jgit/lib/Constants.java
index 7c2cef9..23ac3ac 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/lib/Constants.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/lib/Constants.java
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2008, Robin Rosenberg <[hidden email]>
  * Copyright (C) 2008, Shawn O. Pearce <[hidden email]>
+ * Copyright (C) 2008, Google Inc.
  *
  * All rights reserved.
  *
@@ -38,6 +39,7 @@
 
 package org.spearce.jgit.lib;
 
+import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
@@ -387,6 +389,29 @@ public final class Constants {
  return r;
  }
 
+ /**
+ * Convert a string to a byte array in the standard character encoding.
+ *
+ * @param str
+ *            the string to convert. May contain any Unicode characters.
+ * @return a byte array representing the requested string, encoded using the
+ *         default character encoding (UTF-8).
+ * @see #CHARACTER_ENCODING
+ */
+ public static byte[] encode(final String str) {
+ final ByteBuffer bb = Constants.CHARSET.encode(str);
+ final int len = bb.limit();
+ if (bb.hasArray() && bb.arrayOffset() == 0) {
+ final byte[] arr = bb.array();
+ if (arr.length == len)
+ return arr;
+ }
+
+ final byte[] arr = new byte[len];
+ bb.get(arr);
+ return arr;
+ }
+
  static {
  if (OBJECT_ID_LENGTH != newMessageDigest().getDigestLength())
  throw new LinkageError("Incorrect OBJECT_ID_LENGTH.");
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 04/26] Rely upon Constants.CHARSET over Constants.CHARACTER_ENCODING

Shawn Pearce
This avoids the UnsupportedEncodingException error which we know
must not fail on a JRE that supports jgit.  We have to have the
stock UTF-8 encoding available for basic operation.

In some cases we can also avoid an unnecessary copy.  Some code
paths in the byte[]->String utility methods in the Sun JRE seem
to copy the input byte[] prior to calling the character set for
the conversion.  This copy is unnecessary.

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../src/org/spearce/jgit/lib/ObjectWriter.java     |    2 +-
 .../src/org/spearce/jgit/lib/RefDatabase.java      |    9 +++------
 .../src/org/spearce/jgit/lib/RepositoryConfig.java |    4 ++--
 .../org/spearce/jgit/transport/PacketLineIn.java   |    3 ++-
 .../jgit/transport/SideBandInputStream.java        |    3 ++-
 .../spearce/jgit/transport/TransportBundle.java    |    3 ++-
 .../spearce/jgit/transport/WalkPushConnection.java |    4 ++--
 .../jgit/transport/WalkRemoteObjectDatabase.java   |    5 ++---
 .../src/org/spearce/jgit/treewalk/TreeWalk.java    |   10 ++--------
 .../spearce/jgit/treewalk/filter/PathFilter.java   |   10 +---------
 10 files changed, 19 insertions(+), 34 deletions(-)

diff --git a/org.spearce.jgit/src/org/spearce/jgit/lib/ObjectWriter.java b/org.spearce.jgit/src/org/spearce/jgit/lib/ObjectWriter.java
index be2e28c..6c2cd4f 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/lib/ObjectWriter.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/lib/ObjectWriter.java
@@ -236,7 +236,7 @@ public class ObjectWriter {
  public ObjectId writeTag(final Tag c) throws IOException {
  final ByteArrayOutputStream os = new ByteArrayOutputStream();
  final OutputStreamWriter w = new OutputStreamWriter(os,
- Constants.CHARACTER_ENCODING);
+ Constants.CHARSET);
 
  w.write("object ");
  c.getObjId().copyTo(w);
diff --git a/org.spearce.jgit/src/org/spearce/jgit/lib/RefDatabase.java b/org.spearce.jgit/src/org/spearce/jgit/lib/RefDatabase.java
index 3e68a8d..facd3e4 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/lib/RefDatabase.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/lib/RefDatabase.java
@@ -45,7 +45,6 @@ import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStreamReader;
-import java.io.UnsupportedEncodingException;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -54,8 +53,6 @@ import org.spearce.jgit.util.FS;
 import org.spearce.jgit.util.NB;
 
 class RefDatabase {
- private static final String CHAR_ENC = Constants.CHARACTER_ENCODING;
-
  private static final String REFS_SLASH = "refs/";
 
  private static final String HEADS_SLASH = Constants.HEADS_PREFIX + "/";
@@ -157,7 +154,7 @@ class RefDatabase {
  * @throws IOException
  */
  void link(final String name, final String target) throws IOException {
- final byte[] content = ("ref: " + target + "\n").getBytes(CHAR_ENC);
+ final byte[] content = Constants.encode("ref: " + target + "\n");
  final LockFile lck = new LockFile(fileForRef(name));
  if (!lck.lock())
  throw new ObjectWritingException("Unable to lock " + name);
@@ -438,9 +435,9 @@ class RefDatabase {
  }
 
  private static BufferedReader openReader(final File fileLocation)
- throws UnsupportedEncodingException, FileNotFoundException {
+ throws FileNotFoundException {
  return new BufferedReader(new InputStreamReader(new FileInputStream(
- fileLocation), CHAR_ENC));
+ fileLocation), Constants.CHARSET));
  }
 
 }
diff --git a/org.spearce.jgit/src/org/spearce/jgit/lib/RepositoryConfig.java b/org.spearce.jgit/src/org/spearce/jgit/lib/RepositoryConfig.java
index d1cd5fc..048940d 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/lib/RepositoryConfig.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/lib/RepositoryConfig.java
@@ -517,7 +517,7 @@ public class RepositoryConfig {
  + ".lock");
  final PrintWriter r = new PrintWriter(new BufferedWriter(
  new OutputStreamWriter(new FileOutputStream(tmp),
- Constants.CHARACTER_ENCODING))) {
+ Constants.CHARSET))) {
  @Override
  public void println() {
  print('\n');
@@ -585,7 +585,7 @@ public class RepositoryConfig {
  clear();
  readFile = true;
  final BufferedReader r = new BufferedReader(new InputStreamReader(
- new FileInputStream(configFile), Constants.CHARACTER_ENCODING));
+ new FileInputStream(configFile), Constants.CHARSET));
  try {
  Entry last = null;
  Entry e = new Entry();
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/PacketLineIn.java b/org.spearce.jgit/src/org/spearce/jgit/transport/PacketLineIn.java
index f330638..f87517d 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/PacketLineIn.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/PacketLineIn.java
@@ -47,6 +47,7 @@ import org.spearce.jgit.lib.Constants;
 import org.spearce.jgit.lib.MutableObjectId;
 import org.spearce.jgit.lib.ProgressMonitor;
 import org.spearce.jgit.util.NB;
+import org.spearce.jgit.util.RawParseUtils;
 
 class PacketLineIn {
  private static final byte fromhex[];
@@ -107,7 +108,7 @@ class PacketLineIn {
  final byte[] raw = new byte[len];
  NB.readFully(in, raw, 0, len);
  readLF();
- return new String(raw, 0, len, Constants.CHARACTER_ENCODING);
+ return RawParseUtils.decode(Constants.CHARSET, raw, 0, len);
  }
 
  private void readLF() throws IOException {
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/SideBandInputStream.java b/org.spearce.jgit/src/org/spearce/jgit/transport/SideBandInputStream.java
index 9ccf5ad..3ec9bff 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/SideBandInputStream.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/SideBandInputStream.java
@@ -48,6 +48,7 @@ import org.spearce.jgit.errors.TransportException;
 import org.spearce.jgit.lib.Constants;
 import org.spearce.jgit.lib.ProgressMonitor;
 import org.spearce.jgit.util.NB;
+import org.spearce.jgit.util.RawParseUtils;
 
 /**
  * Unmultiplexes the data portion of a side-band channel.
@@ -194,6 +195,6 @@ class SideBandInputStream extends InputStream {
  private String readString(final int len) throws IOException {
  final byte[] raw = new byte[len];
  NB.readFully(in, raw, 0, len);
- return new String(raw, 0, len, Constants.CHARACTER_ENCODING);
+ return RawParseUtils.decode(Constants.CHARSET, raw, 0, len);
  }
 }
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportBundle.java b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportBundle.java
index 24d49eb..d8c2ba4 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportBundle.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportBundle.java
@@ -58,6 +58,7 @@ import org.spearce.jgit.lib.ProgressMonitor;
 import org.spearce.jgit.lib.Ref;
 import org.spearce.jgit.lib.Repository;
 import org.spearce.jgit.util.FS;
+import org.spearce.jgit.util.RawParseUtils;
 
 /**
  * Supports fetching from a git bundle (sneaker-net object transport).
@@ -193,7 +194,7 @@ class TransportBundle extends PackTransport {
  bin.skip(lf);
  if (lf < cnt && hdrbuf[lf] == '\n')
  bin.skip(1);
- return new String(hdrbuf, 0, lf, Constants.CHARACTER_ENCODING);
+ return RawParseUtils.decode(Constants.CHARSET, hdrbuf, 0, lf);
  }
 
  @Override
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/WalkPushConnection.java b/org.spearce.jgit/src/org/spearce/jgit/transport/WalkPushConnection.java
index 904a699..85bbc14 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/WalkPushConnection.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/WalkPushConnection.java
@@ -325,7 +325,7 @@ class WalkPushConnection extends BaseConnection implements PushConnection {
  throws TransportException {
  try {
  final String ref = "ref: " + pickHEAD(updates) + "\n";
- final byte[] bytes = ref.getBytes(Constants.CHARACTER_ENCODING);
+ final byte[] bytes = Constants.encode(ref);
  dest.writeFile("../HEAD", bytes);
  } catch (IOException e) {
  throw new TransportException(uri, "cannot create HEAD", e);
@@ -334,7 +334,7 @@ class WalkPushConnection extends BaseConnection implements PushConnection {
  try {
  final String config = "[core]\n"
  + "\trepositoryformatversion = 0\n";
- final byte[] bytes = config.getBytes(Constants.CHARACTER_ENCODING);
+ final byte[] bytes = Constants.encode(config);
  dest.writeFile("../config", bytes);
  } catch (IOException e) {
  throw new TransportException(uri, "cannot create config", e);
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/WalkRemoteObjectDatabase.java b/org.spearce.jgit/src/org/spearce/jgit/transport/WalkRemoteObjectDatabase.java
index c5a5199..ababc69 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/WalkRemoteObjectDatabase.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/WalkRemoteObjectDatabase.java
@@ -67,8 +67,6 @@ import org.spearce.jgit.util.NB;
  * independent {@link WalkFetchConnection}.
  */
 abstract class WalkRemoteObjectDatabase {
- static final String CHARENC = Constants.CHARACTER_ENCODING;
-
  static final String INFO_PACKS = "info/packs";
 
  static final String INFO_ALTERNATES = "info/alternates";
@@ -448,7 +446,8 @@ abstract class WalkRemoteObjectDatabase {
  *             stream could be created.
  */
  BufferedReader openReader(final String path) throws IOException {
- return new BufferedReader(new InputStreamReader(open(path).in, CHARENC));
+ final InputStream is = open(path).in;
+ return new BufferedReader(new InputStreamReader(is, Constants.CHARSET));
  }
 
  /**
diff --git a/org.spearce.jgit/src/org/spearce/jgit/treewalk/TreeWalk.java b/org.spearce.jgit/src/org/spearce/jgit/treewalk/TreeWalk.java
index 9f373e6..d4050ec 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/treewalk/TreeWalk.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/treewalk/TreeWalk.java
@@ -38,7 +38,6 @@
 package org.spearce.jgit.treewalk;
 
 import java.io.IOException;
-import java.io.UnsupportedEncodingException;
 import java.util.Collections;
 
 import org.spearce.jgit.errors.CorruptObjectException;
@@ -52,6 +51,7 @@ import org.spearce.jgit.lib.Repository;
 import org.spearce.jgit.revwalk.RevTree;
 import org.spearce.jgit.treewalk.filter.PathFilterGroup;
 import org.spearce.jgit.treewalk.filter.TreeFilter;
+import org.spearce.jgit.util.RawParseUtils;
 
 /**
  * Walks one or more {@link AbstractTreeIterator}s in parallel.
@@ -685,12 +685,6 @@ public class TreeWalk {
  }
 
  private static String pathOf(final AbstractTreeIterator t) {
- try {
- return new String(t.path, 0, t.pathLen,
- Constants.CHARACTER_ENCODING);
- } catch (UnsupportedEncodingException uee) {
- throw new RuntimeException("JVM doesn't support "
- + Constants.CHARACTER_ENCODING, uee);
- }
+ return RawParseUtils.decode(Constants.CHARSET, t.path, 0, t.pathLen);
  }
 }
diff --git a/org.spearce.jgit/src/org/spearce/jgit/treewalk/filter/PathFilter.java b/org.spearce.jgit/src/org/spearce/jgit/treewalk/filter/PathFilter.java
index 3aff145..56773a3 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/treewalk/filter/PathFilter.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/treewalk/filter/PathFilter.java
@@ -37,8 +37,6 @@
 
 package org.spearce.jgit.treewalk.filter;
 
-import java.io.UnsupportedEncodingException;
-
 import org.spearce.jgit.lib.Constants;
 import org.spearce.jgit.treewalk.TreeWalk;
 
@@ -81,13 +79,7 @@ public class PathFilter extends TreeFilter {
 
  private PathFilter(final String s) {
  pathStr = s;
- try {
- pathRaw = pathStr.getBytes(Constants.CHARACTER_ENCODING);
- } catch (UnsupportedEncodingException uee) {
- throw new RuntimeException("JVM doesn't support "
- + Constants.CHARACTER_ENCODING
- + " which is required for path filtering.", uee);
- }
+ pathRaw = Constants.encode(pathStr);
  }
 
  @Override
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 05/26] Allow AbstractTreeIterators to find out about StopWalkExceptions

Shawn Pearce
If a tree iterator has overridden skip() to specially handle entries
which the TreeWalk has decided are not relevant then it might also
need to pay attention to a StopWalkException.  The SWE is thrown out
of a filter and behaves much like skip, except it skips everything
else in the tree.  This is used by PathFilterGroup to break out of
a walk once we know that no additional records could ever match.

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../jgit/treewalk/AbstractTreeIterator.java        |   11 +++++++++++
 .../spearce/jgit/treewalk/EmptyTreeIterator.java   |    6 ++++++
 .../src/org/spearce/jgit/treewalk/TreeWalk.java    |    2 ++
 3 files changed, 19 insertions(+), 0 deletions(-)

diff --git a/org.spearce.jgit/src/org/spearce/jgit/treewalk/AbstractTreeIterator.java b/org.spearce.jgit/src/org/spearce/jgit/treewalk/AbstractTreeIterator.java
index 6d7159c..98fec09 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/treewalk/AbstractTreeIterator.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/treewalk/AbstractTreeIterator.java
@@ -391,4 +391,15 @@ public abstract class AbstractTreeIterator {
  public void skip() throws CorruptObjectException {
  next();
  }
+
+ /**
+ * Indicates to the iterator that no more entries will be read.
+ * <p>
+ * This is only invoked by TreeWalk when the iteration is aborted early due
+ * to a {@link org.spearce.jgit.errors.StopWalkException} being thrown from
+ * within a TreeFilter.
+ */
+ public void stopWalk() {
+ // Do nothing by default.  Most iterators do not care.
+ }
 }
diff --git a/org.spearce.jgit/src/org/spearce/jgit/treewalk/EmptyTreeIterator.java b/org.spearce.jgit/src/org/spearce/jgit/treewalk/EmptyTreeIterator.java
index 09d2bde..c5dc4ad 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/treewalk/EmptyTreeIterator.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/treewalk/EmptyTreeIterator.java
@@ -87,4 +87,10 @@ public class EmptyTreeIterator extends AbstractTreeIterator {
  public void next() throws CorruptObjectException {
  // Do nothing.
  }
+
+ @Override
+ public void stopWalk() {
+ if (parent != null)
+ parent.stopWalk();
+ }
 }
diff --git a/org.spearce.jgit/src/org/spearce/jgit/treewalk/TreeWalk.java b/org.spearce.jgit/src/org/spearce/jgit/treewalk/TreeWalk.java
index d4050ec..1d842bc 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/treewalk/TreeWalk.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/treewalk/TreeWalk.java
@@ -408,6 +408,8 @@ public class TreeWalk {
  return true;
  }
  } catch (StopWalkException stop) {
+ for (final AbstractTreeIterator t : trees)
+ t.stopWalk();
  return false;
  }
  }
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 06/26] Implement a new .git/index (aka dircache) read interface

Shawn Pearce
This is a smaller (and faster) .git/index file reader and it will be
an eventual replacement for the current GitIndex class.

We silently skip optional extensions, which means we silently skip the
current 'TREE' extension.  We also fail out if we identify a required
extension which we do not support.

Most of each index entry is held in a shared byte[] as we do not need
most of the fields in jgit, due to Java's lack of a POSIX lstat like
utility.  This makes it more efficient for us to read the C Git index
format as we can avoid expending a lot of CPU on decode calls during
the file read.

Lookup is handled by binary searching against the encoded paths, as
this lines up better with how TreeWalk and its TreeFilters operate.
Most of the time when we are looking for something in the index it
is a quick read-find+update-write cycle affecting only a handful of
paths.  Avoiding any unnecessary byte[]->String->byte[] translations
during these operations performance.

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../src/org/spearce/jgit/dircache/DirCache.java    |  385 ++++++++++++++++++++
 .../org/spearce/jgit/dircache/DirCacheEntry.java   |  270 ++++++++++++++
 2 files changed, 655 insertions(+), 0 deletions(-)
 create mode 100644 org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
 create mode 100644 org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEntry.java

diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
new file mode 100644
index 0000000..f8ca60d
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
@@ -0,0 +1,385 @@
+/*
+ * Copyright (C) 2008, Shawn O. Pearce <[hidden email]>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.dircache;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.util.Comparator;
+
+import org.spearce.jgit.errors.CorruptObjectException;
+import org.spearce.jgit.lib.Constants;
+import org.spearce.jgit.lib.Repository;
+import org.spearce.jgit.util.NB;
+
+/**
+ * Support for the Git dircache (aka index file).
+ * <p>
+ * The index file keeps track of which objects are currently checked out in the
+ * working directory, and the last modified time of those working files. Changes
+ * in the working directory can be detected by comparing the modification times
+ * to the cached modification time within the index file.
+ * <p>
+ * Index files are also used during merges, where the merge happens within the
+ * index file first, and the working directory is updated as a post-merge step.
+ * Conflicts are stored in the index file to allow tool (and human) based
+ * resolutions to be easily performed.
+ */
+public class DirCache {
+ private static final byte[] SIG_DIRC = { 'D', 'I', 'R', 'C' };
+
+ private static final int INFO_LEN = DirCacheEntry.INFO_LEN;
+
+ private static final DirCacheEntry[] NO_ENTRIES = {};
+
+ static final Comparator<DirCacheEntry> ENT_CMP = new Comparator<DirCacheEntry>() {
+ public int compare(final DirCacheEntry o1, final DirCacheEntry o2) {
+ final int cr = cmp(o1, o2);
+ if (cr != 0)
+ return cr;
+ return o1.getStage() - o2.getStage();
+ }
+ };
+
+ static int cmp(final DirCacheEntry a, final DirCacheEntry b) {
+ return cmp(a.path, a.path.length, b);
+ }
+
+ static int cmp(final byte[] aPath, final int aLen, final DirCacheEntry b) {
+ return cmp(aPath, aLen, b.path, b.path.length);
+ }
+
+ static int cmp(final byte[] aPath, final int aLen, final byte[] bPath,
+ final int bLen) {
+ for (int cPos = 0; cPos < aLen && cPos < bLen; cPos++) {
+ final int cmp = (aPath[cPos] & 0xff) - (bPath[cPos] & 0xff);
+ if (cmp != 0)
+ return cmp;
+ }
+ return aLen - bLen;
+ }
+
+ /**
+ * Create a new in-core index representation and read an index from disk.
+ * <p>
+ * The new index will be read before it is returned to the caller. Read
+ * failures are reported as exceptions and therefore prevent the method from
+ * returning a partially populated index.
+ *
+ * @param indexLocation
+ *            location of the index file on disk.
+ * @return a cache representing the contents of the specified index file (if
+ *         it exists) or an empty cache if the file does not exist.
+ * @throws IOException
+ *             the index file is present but could not be read.
+ * @throws CorruptObjectException
+ *             the index file is using a format or extension that this
+ *             library does not support.
+ */
+ public static DirCache read(final File indexLocation)
+ throws CorruptObjectException, IOException {
+ final DirCache c = new DirCache(indexLocation);
+ c.read();
+ return c;
+ }
+
+ /**
+ * Create a new in-core index representation and read an index from disk.
+ * <p>
+ * The new index will be read before it is returned to the caller. Read
+ * failures are reported as exceptions and therefore prevent the method from
+ * returning a partially populated index.
+ *
+ * @param db
+ *            repository the caller wants to read the default index of.
+ * @return a cache representing the contents of the specified index file (if
+ *         it exists) or an empty cache if the file does not exist.
+ * @throws IOException
+ *             the index file is present but could not be read.
+ * @throws CorruptObjectException
+ *             the index file is using a format or extension that this
+ *             library does not support.
+ */
+ public static DirCache read(final Repository db)
+ throws CorruptObjectException, IOException {
+ return read(new File(db.getDirectory(), "index"));
+ }
+
+ /** Location of the current version of the index file. */
+ private final File liveFile;
+
+ /** Modification time of the file at the last read/write we did. */
+ private long lastModified;
+
+ /** Individual file index entries, sorted by path name. */
+ private DirCacheEntry[] sortedEntries;
+
+ /** Number of positions within {@link #sortedEntries} that are valid. */
+ private int entryCnt;
+
+ /**
+ * Create a new in-core index representation.
+ * <p>
+ * The new index will be empty. Callers may wish to read from the on disk
+ * file first with {@link #read()}.
+ *
+ * @param indexLocation
+ *            location of the index file on disk.
+ */
+ public DirCache(final File indexLocation) {
+ liveFile = indexLocation;
+ clear();
+ }
+
+ /**
+ * Read the index from disk, if it has changed on disk.
+ * <p>
+ * This method tries to avoid loading the index if it has not changed since
+ * the last time we consulted it. A missing index file will be treated as
+ * though it were present but had no file entries in it.
+ *
+ * @throws IOException
+ *             the index file is present but could not be read. This
+ *             DirCache instance may not be populated correctly.
+ * @throws CorruptObjectException
+ *             the index file is using a format or extension that this
+ *             library does not support.
+ */
+ public void read() throws IOException, CorruptObjectException {
+ if (!liveFile.exists())
+ clear();
+ else if (liveFile.lastModified() != lastModified) {
+ try {
+ final FileInputStream inStream = new FileInputStream(liveFile);
+ try {
+ clear();
+ readFrom(inStream);
+ } finally {
+ try {
+ inStream.close();
+ } catch (IOException err2) {
+ // Ignore any close failures.
+ }
+ }
+ } catch (FileNotFoundException fnfe) {
+ // Someone must have deleted it between our exists test
+ // and actually opening the path. That's fine, its empty.
+ //
+ clear();
+ }
+ }
+ }
+
+ /** Empty this index, removing all entries. */
+ public void clear() {
+ lastModified = 0;
+ sortedEntries = NO_ENTRIES;
+ entryCnt = 0;
+ }
+
+ private void readFrom(final FileInputStream inStream) throws IOException,
+ CorruptObjectException {
+ final FileChannel fd = inStream.getChannel();
+ final long sizeOnDisk = fd.size();
+ final BufferedInputStream in = new BufferedInputStream(inStream);
+
+ // Read the index header and verify we understand it.
+ //
+ final byte[] hdr = new byte[12];
+ NB.readFully(in, hdr, 0, 12);
+ if (!is_DIRC(hdr))
+ throw new CorruptObjectException("Not a DIRC file.");
+ final int ver = NB.decodeInt32(hdr, 4);
+ if (ver != 2)
+ throw new CorruptObjectException("Unknown DIRC version " + ver);
+ entryCnt = NB.decodeInt32(hdr, 8);
+ if (entryCnt < 0)
+ throw new CorruptObjectException("DIRC has too many entries.");
+
+ // Load the individual file entries.
+ //
+ final byte[] infos = new byte[INFO_LEN * entryCnt];
+ sortedEntries = new DirCacheEntry[entryCnt];
+ for (int i = 0; i < entryCnt; i++)
+ sortedEntries[i] = new DirCacheEntry(infos, i * INFO_LEN, in);
+ lastModified = liveFile.lastModified();
+
+ // After the file entries are index extensions.
+ //
+ while (fd.position() - in.available() < sizeOnDisk - 20) {
+ NB.readFully(in, hdr, 0, 8);
+ switch (NB.decodeInt32(hdr, 0)) {
+ default:
+ if (hdr[0] >= 'A' && hdr[0] <= 'Z') {
+ // The extension is optional and is here only as
+ // a performance optimization. Since we do not
+ // understand it, we can safely skip past it.
+ //
+ in.skip(NB.decodeInt32(hdr, 4));
+ } else {
+ // The extension is not an optimization and is
+ // _required_ to understand this index format.
+ // Since we did not trap it above we must abort.
+ //
+ throw new CorruptObjectException("DIRC extension '"
+ + Constants.CHARSET.decode(
+ ByteBuffer.wrap(hdr, 0, 4)).toString()
+ + "' not supported by this version.");
+ }
+ }
+ }
+ }
+
+ private static boolean is_DIRC(final byte[] hdr) {
+ if (hdr.length < SIG_DIRC.length)
+ return false;
+ for (int i = 0; i < SIG_DIRC.length; i++)
+ if (hdr[i] != SIG_DIRC[i])
+ return false;
+ return true;
+ }
+
+ /**
+ * Locate the position a path's entry is at in the index.
+ * <p>
+ * If there is at least one entry in the index for this path the position of
+ * the lowest stage is returned. Subsequent stages can be identified by
+ * testing consecutive entries until the path differs.
+ * <p>
+ * If no path matches the entry -(position+1) is returned, where position is
+ * the location it would have gone within the index.
+ *
+ * @param path
+ *            the path to search for.
+ * @return if >= 0 then the return value is the position of the entry in the
+ *         index; pass to {@link #getEntry(int)} to obtain the entry
+ *         information. If < 0 the entry does not exist in the index.
+ */
+ public int findEntry(final String path) {
+ if (entryCnt == 0)
+ return -1;
+ final byte[] p = Constants.encode(path);
+ return findEntry(p, p.length);
+ }
+
+ int findEntry(final byte[] p, final int pLen) {
+ int low = 0;
+ int high = entryCnt;
+ do {
+ int mid = (low + high) >> 1;
+ final int cmp = cmp(p, pLen, sortedEntries[mid]);
+ if (cmp < 0)
+ high = mid;
+ else if (cmp == 0) {
+ while (mid > 0 && cmp(p, pLen, sortedEntries[mid - 1]) == 0)
+ mid--;
+ return mid;
+ } else
+ low = mid + 1;
+ } while (low < high);
+ return -(low + 1);
+ }
+
+ /**
+ * Determine the next index position past all entries with the same name.
+ * <p>
+ * As index entries are sorted by path name, then stage number, this method
+ * advances the supplied position to the first position in the index whose
+ * path name does not match the path name of the supplied position's entry.
+ *
+ * @param position
+ *            entry position of the path that should be skipped.
+ * @return position of the next entry whose path is after the input.
+ */
+ public int nextEntry(final int position) {
+ DirCacheEntry last = sortedEntries[position];
+ int nextIdx = position + 1;
+ while (nextIdx < entryCnt) {
+ final DirCacheEntry next = sortedEntries[nextIdx];
+ if (cmp(last, next) != 0)
+ break;
+ last = next;
+ nextIdx++;
+ }
+ return nextIdx;
+ }
+
+ /**
+ * Total number of file entries stored in the index.
+ * <p>
+ * This count includes unmerged stages for a file entry if the file is
+ * currently conflicted in a merge. This means the total number of entries
+ * in the index may be up to 3 times larger than the number of files in the
+ * working directory.
+ * <p>
+ * Note that this value counts only <i>files</i>.
+ *
+ * @return number of entries available.
+ * @see #getEntry(int)
+ */
+ public int getEntryCount() {
+ return entryCnt;
+ }
+
+ /**
+ * Get a specific entry.
+ *
+ * @param i
+ *            position of the entry to get.
+ * @return the entry at position <code>i</code>.
+ */
+ public DirCacheEntry getEntry(final int i) {
+ return sortedEntries[i];
+ }
+
+ /**
+ * Get a specific entry.
+ *
+ * @param path
+ *            the path to search for.
+ * @return the entry at position <code>i</code>.
+ */
+ public DirCacheEntry getEntry(final String path) {
+ final int i = findEntry(path);
+ return i < 0 ? null : sortedEntries[i];
+ }
+}
diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEntry.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEntry.java
new file mode 100644
index 0000000..7efab48
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEntry.java
@@ -0,0 +1,270 @@
+/*
+ * Copyright (C) 2008, Shawn O. Pearce <[hidden email]>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.dircache;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+
+import org.spearce.jgit.lib.Constants;
+import org.spearce.jgit.lib.FileMode;
+import org.spearce.jgit.lib.ObjectId;
+import org.spearce.jgit.util.NB;
+
+/**
+ * A single file (or stage of a file) in a {@link DirCache}.
+ * <p>
+ * An entry represents exactly one stage of a file. If a file path is unmerged
+ * then multiple DirCacheEntry instances may appear for the same path name.
+ */
+public class DirCacheEntry {
+ // private static final int P_CTIME = 0;
+
+ // private static final int P_CTIME_NSEC = 4;
+
+ private static final int P_MTIME = 8;
+
+ // private static final int P_MTIME_NSEC = 12;
+
+ // private static final int P_DEV = 16;
+
+ // private static final int P_INO = 20;
+
+ private static final int P_MODE = 24;
+
+ // private static final int P_UID = 28;
+
+ // private static final int P_GID = 32;
+
+ private static final int P_SIZE = 36;
+
+ private static final int P_OBJECTID = 40;
+
+ private static final int P_FLAGS = 60;
+
+ static final int INFO_LEN = 62;
+
+ private static final int ASSUME_VALID = 0x80;
+
+ /** (Possibly shared) header information storage. */
+ private final byte[] info;
+
+ /** First location within {@link #info} where our header starts. */
+ private final int infoOffset;
+
+ /** Our encoded path name, from the root of the repository. */
+ final byte[] path;
+
+ DirCacheEntry(final byte[] sharedInfo, final int infoAt,
+ final InputStream in) throws IOException {
+ info = sharedInfo;
+ infoOffset = infoAt;
+
+ NB.readFully(in, info, infoOffset, INFO_LEN);
+
+ int pathLen = NB.decodeUInt16(info, infoOffset + P_FLAGS) & 0xfff;
+ path = new byte[pathLen];
+ NB.readFully(in, path, 0, pathLen);
+
+ // Index records are padded out to the next 8 byte alignment
+ // for historical reasons related to how C Git read the files.
+ //
+ final int actLen = INFO_LEN + pathLen;
+ final int expLen = (actLen + 8) & ~7;
+ if (actLen != expLen)
+ in.skip(expLen - actLen);
+ }
+
+ final byte[] idBuffer() {
+ return info;
+ }
+
+ final int idOffset() {
+ return infoOffset + P_OBJECTID;
+ }
+
+ /**
+ * Is this entry always thought to be unmodified?
+ * <p>
+ * Most entries in the index do not have this flag set. Users may however
+ * set them on if the file system stat() costs are too high on this working
+ * directory, such as on NFS or SMB volumes.
+ *
+ * @return true if we must assume the entry is unmodified.
+ */
+ public boolean isAssumeValid() {
+ return (info[infoOffset + P_FLAGS] & ASSUME_VALID) != 0;
+ }
+
+ /**
+ * Set the assume valid flag for this entry,
+ *
+ * @param assume
+ *            true to ignore apparent modifications; false to look at last
+ *            modified to detect file modifications.
+ */
+ public void setAssumeValid(final boolean assume) {
+ if (assume)
+ info[infoOffset + P_FLAGS] |= ASSUME_VALID;
+ else
+ info[infoOffset + P_FLAGS] &= ~ASSUME_VALID;
+ }
+
+ /**
+ * Get the stage of this entry.
+ * <p>
+ * Entries have one of 4 possible stages: 0-3.
+ *
+ * @return the stage of this entry.
+ */
+ public int getStage() {
+ return (info[infoOffset + P_FLAGS] >>> 4) & 0x3;
+ }
+
+ /**
+ * Obtain the raw {@link FileMode} bits for this entry.
+ *
+ * @return mode bits for the entry.
+ * @see FileMode#fromBits(int)
+ */
+ public int getRawMode() {
+ return NB.decodeInt32(info, infoOffset + P_MODE);
+ }
+
+ /**
+ * Set the file mode for this entry.
+ *
+ * @param mode
+ *            the new mode constant.
+ */
+ public void setFileMode(final FileMode mode) {
+ NB.encodeInt32(info, infoOffset + P_MODE, mode.getBits());
+ }
+
+ /**
+ * Get the cached last modification date of this file, in milliseconds.
+ * <p>
+ * One of the indicators that the file has been modified by an application
+ * changing the working tree is if the last modification time for the file
+ * differs from the time stored in this entry.
+ *
+ * @return last modification time of this file, in milliseconds since the
+ *         Java epoch (midnight Jan 1, 1970 UTC).
+ */
+ public long getLastModified() {
+ return decodeTS(P_MTIME);
+ }
+
+ /**
+ * Set the cached last modification date of this file, using milliseconds.
+ *
+ * @param when
+ *            new cached modification date of the file, in milliseconds.
+ */
+ public void setLastModified(final long when) {
+ encodeTS(P_MTIME, when);
+ }
+
+ /**
+ * Get the cached size (in bytes) of this file.
+ * <p>
+ * One of the indicators that the file has been modified by an application
+ * changing the working tree is if the size of the file (in bytes) differs
+ * from the size stored in this entry.
+ * <p>
+ * Note that this is the length of the file in the working directory, which
+ * may differ from the size of the decompressed blob if work tree filters
+ * are being used, such as LF<->CRLF conversion.
+ *
+ * @return cached size of the working directory file, in bytes.
+ */
+ public int getLength() {
+ return NB.decodeInt32(info, infoOffset + P_SIZE);
+ }
+
+ /**
+ * Set the cached size (in bytes) of this file.
+ *
+ * @param sz
+ *            new cached size of the file, as bytes.
+ */
+ public void setLength(final int sz) {
+ NB.encodeInt32(info, infoOffset + P_SIZE, sz);
+ }
+
+ /**
+ * Obtain the ObjectId for the entry.
+ * <p>
+ * Using this method to compare ObjectId values between entries is
+ * inefficient as it causes memory allocation.
+ *
+ * @return object identifier for the entry.
+ */
+ public ObjectId getObjectId() {
+ return ObjectId.fromRaw(idBuffer(), idOffset());
+ }
+
+ /**
+ * Get the entry's complete path.
+ * <p>
+ * This method is not very efficient and is primarily meant for debugging
+ * and final output generation. Applications should try to avoid calling it,
+ * and if invoked do so only once per interesting entry, where the name is
+ * absolutely required for correct function.
+ *
+ * @return complete path of the entry, from the root of the repository. If
+ *         the entry is in a subtree there will be at least one '/' in the
+ *         returned string.
+ */
+ public String getPathString() {
+ return Constants.CHARSET.decode(ByteBuffer.wrap(path)).toString();
+ }
+
+ private long decodeTS(final int pIdx) {
+ final int base = infoOffset + pIdx;
+ final int sec = NB.decodeInt32(info, base);
+ final int ms = NB.decodeInt32(info, base + 4) / 1000000;
+ return 1000L * sec + ms;
+ }
+
+ private void encodeTS(final int pIdx, final long when) {
+ final int base = infoOffset + pIdx;
+ NB.encodeInt32(info, base, (int) (when / 1000));
+ NB.encodeInt32(info, base + 4, ((int) (when % 1000)) * 1000000);
+ }
+}
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 07/26] Export the new DirCache API to Eclipse plugins using jgit

Shawn Pearce
Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 org.spearce.jgit/META-INF/MANIFEST.MF |    3 ++-
 1 files changed, 2 insertions(+), 1 deletions(-)

diff --git a/org.spearce.jgit/META-INF/MANIFEST.MF b/org.spearce.jgit/META-INF/MANIFEST.MF
index 388dc18..36f92f2 100644
--- a/org.spearce.jgit/META-INF/MANIFEST.MF
+++ b/org.spearce.jgit/META-INF/MANIFEST.MF
@@ -5,7 +5,8 @@ Bundle-SymbolicName: org.spearce.jgit
 Bundle-Version: 0.3.1.qualifier
 Bundle-Localization: plugin
 Bundle-Vendor: %provider_name
-Export-Package: org.spearce.jgit.errors;uses:="org.spearce.jgit.lib",
+Export-Package: org.spearce.jgit.dircache,
+ org.spearce.jgit.errors;uses:="org.spearce.jgit.lib",
  org.spearce.jgit.lib,
  org.spearce.jgit.revplot,
  org.spearce.jgit.revwalk,
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 08/26] Support locking (and unlocking) a .git/index through DirCache

Shawn Pearce
In order to safely perform an update of the .git/index file (or any
other DirCache file) we need to lock the file prior to reading its
contents into memory.  This ensures that the contents will not be
modified between the time we start processing the entires and when
the update operation is completed.

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../src/org/spearce/jgit/dircache/DirCache.java    |   86 ++++++++++++++++++++
 1 files changed, 86 insertions(+), 0 deletions(-)

diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
index f8ca60d..8f38a79 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
@@ -48,6 +48,7 @@ import java.util.Comparator;
 
 import org.spearce.jgit.errors.CorruptObjectException;
 import org.spearce.jgit.lib.Constants;
+import org.spearce.jgit.lib.LockFile;
 import org.spearce.jgit.lib.Repository;
 import org.spearce.jgit.util.NB;
 
@@ -144,6 +145,56 @@ public class DirCache {
  return read(new File(db.getDirectory(), "index"));
  }
 
+ /**
+ * Create a new in-core index representation, lock it, and read from disk.
+ * <p>
+ * The new index will be locked and then read before it is returned to the
+ * caller. Read failures are reported as exceptions and therefore prevent
+ * the method from returning a partially populated index.
+ *
+ * @param indexLocation
+ *            location of the index file on disk.
+ * @return a cache representing the contents of the specified index file (if
+ *         it exists) or an empty cache if the file does not exist.
+ * @throws IOException
+ *             the index file is present but could not be read, or the lock
+ *             could not be obtained.
+ * @throws CorruptObjectException
+ *             the index file is using a format or extension that this
+ *             library does not support.
+ */
+ public static DirCache lock(final File indexLocation)
+ throws CorruptObjectException, IOException {
+ final DirCache c = new DirCache(indexLocation);
+ if (!c.lock())
+ throw new IOException("Cannot lock " + indexLocation);
+ c.read();
+ return c;
+ }
+
+ /**
+ * Create a new in-core index representation, lock it, and read from disk.
+ * <p>
+ * The new index will be locked and then read before it is returned to the
+ * caller. Read failures are reported as exceptions and therefore prevent
+ * the method from returning a partially populated index.
+ *
+ * @param db
+ *            repository the caller wants to read the default index of.
+ * @return a cache representing the contents of the specified index file (if
+ *         it exists) or an empty cache if the file does not exist.
+ * @throws IOException
+ *             the index file is present but could not be read, or the lock
+ *             could not be obtained.
+ * @throws CorruptObjectException
+ *             the index file is using a format or extension that this
+ *             library does not support.
+ */
+ public static DirCache lock(final Repository db)
+ throws CorruptObjectException, IOException {
+ return lock(new File(db.getDirectory(), "index"));
+ }
+
  /** Location of the current version of the index file. */
  private final File liveFile;
 
@@ -156,6 +207,9 @@ public class DirCache {
  /** Number of positions within {@link #sortedEntries} that are valid. */
  private int entryCnt;
 
+ /** Our active lock (if we hold it); null if we don't have it locked. */
+ private LockFile myLock;
+
  /**
  * Create a new in-core index representation.
  * <p>
@@ -279,6 +333,38 @@ public class DirCache {
  }
 
  /**
+ * Try to establish an update lock on the cache file.
+ *
+ * @return true if the lock is now held by the caller; false if it is held
+ *         by someone else.
+ * @throws IOException
+ *             the output file could not be created. The caller does not
+ *             hold the lock.
+ */
+ public boolean lock() throws IOException {
+ final LockFile tmp = new LockFile(liveFile);
+ if (tmp.lock()) {
+ tmp.setNeedStatInformation(true);
+ myLock = tmp;
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Unlock this file and abort this change.
+ * <p>
+ * The temporary file (if created) is deleted before returning.
+ */
+ public void unlock() {
+ final LockFile tmp = myLock;
+ if (tmp != null) {
+ myLock = null;
+ tmp.unlock();
+ }
+ }
+
+ /**
  * Locate the position a path's entry is at in the index.
  * <p>
  * If there is at least one entry in the index for this path the position of
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 09/26] Support writing a .git/index through DirCache

Shawn Pearce
We now support writing back the same entires we read in, with maybe
some minor entry level edits such as to change the mode of an entry,
or the assume valid flag.

We also include full support for smudging potentially 'racily clean'
entries while writing an updated index file back to disk.  We differ
from C Git in how we smudge an entry, but the effect should be the
same in that potentially racily clean entries will require C Git to
compare the content of the file, at least until Jan 19, 2038.  The
smudge rule needs to be different because we do not have access to
the working directory in order to validate a racily clean entry.

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../src/org/spearce/jgit/dircache/DirCache.java    |   97 ++++++++++++++++++++
 .../org/spearce/jgit/dircache/DirCacheEntry.java   |   75 +++++++++++++++
 2 files changed, 172 insertions(+), 0 deletions(-)

diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
index 8f38a79..248e2a2 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
@@ -38,12 +38,16 @@
 package org.spearce.jgit.dircache;
 
 import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
+import java.io.OutputStream;
 import java.nio.ByteBuffer;
 import java.nio.channels.FileChannel;
+import java.security.DigestOutputStream;
+import java.security.MessageDigest;
 import java.util.Comparator;
 
 import org.spearce.jgit.errors.CorruptObjectException;
@@ -352,6 +356,99 @@ public class DirCache {
  }
 
  /**
+ * Write the entry records from memory to disk.
+ * <p>
+ * The cache must be locked first by calling {@link #lock()} and receiving
+ * true as the return value. Applications are encouraged to lock the index,
+ * then invoke {@link #read()} to ensure the in-memory data is current,
+ * prior to updating the in-memory entries.
+ * <p>
+ * Once written the lock is closed and must be either committed with
+ * {@link #commit()} or rolled back with {@link #unlock()}.
+ *
+ * @throws IOException
+ *             the output file could not be created. The caller no longer
+ *             holds the lock.
+ */
+ public void write() throws IOException {
+ final LockFile tmp = myLock;
+ requireLocked(tmp);
+ try {
+ writeTo(new BufferedOutputStream(tmp.getOutputStream()));
+ } catch (IOException err) {
+ tmp.unlock();
+ throw err;
+ } catch (RuntimeException err) {
+ tmp.unlock();
+ throw err;
+ } catch (Error err) {
+ tmp.unlock();
+ throw err;
+ }
+ }
+
+ private void writeTo(final OutputStream os) throws IOException {
+ final MessageDigest foot = Constants.newMessageDigest();
+ final DigestOutputStream dos = new DigestOutputStream(os, foot);
+
+ // Write the header.
+ //
+ final byte[] tmp = new byte[128];
+ System.arraycopy(SIG_DIRC, 0, tmp, 0, SIG_DIRC.length);
+ NB.encodeInt32(tmp, 4, /* version */2);
+ NB.encodeInt32(tmp, 8, entryCnt);
+ dos.write(tmp, 0, 12);
+
+ // Write the individual file entries.
+ //
+ if (lastModified <= 0) {
+ // Write a new index, as no entries require smudging.
+ //
+ for (int i = 0; i < entryCnt; i++)
+ sortedEntries[i].write(dos);
+ } else {
+ final int smudge_s = (int) (lastModified / 1000);
+ final int smudge_ns = ((int) (lastModified % 1000)) * 1000000;
+ for (int i = 0; i < entryCnt; i++) {
+ final DirCacheEntry e = sortedEntries[i];
+ if (e.mightBeRacilyClean(smudge_s, smudge_ns))
+ e.smudgeRacilyClean();
+ e.write(dos);
+ }
+ }
+
+ os.write(foot.digest());
+ os.close();
+ }
+
+ /**
+ * Commit this change and release the lock.
+ * <p>
+ * If this method fails (returns false) the lock is still released.
+ *
+ * @return true if the commit was successful and the file contains the new
+ *         data; false if the commit failed and the file remains with the
+ *         old data.
+ * @throws IllegalStateException
+ *             the lock is not held.
+ */
+ public boolean commit() {
+ final LockFile tmp = myLock;
+ requireLocked(tmp);
+ myLock = null;
+ if (!tmp.commit())
+ return false;
+ lastModified = tmp.getCommitLastModified();
+ return true;
+ }
+
+ private void requireLocked(final LockFile tmp) {
+ if (tmp == null)
+ throw new IllegalStateException("DirCache "
+ + liveFile.getAbsolutePath() + " not locked.");
+ }
+
+ /**
  * Unlock this file and abort this change.
  * <p>
  * The temporary file (if created) is deleted before returning.
diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEntry.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEntry.java
index 7efab48..8ca8f22 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEntry.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEntry.java
@@ -39,7 +39,9 @@ package org.spearce.jgit.dircache;
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.OutputStream;
 import java.nio.ByteBuffer;
+import java.util.Arrays;
 
 import org.spearce.jgit.lib.Constants;
 import org.spearce.jgit.lib.FileMode;
@@ -53,6 +55,8 @@ import org.spearce.jgit.util.NB;
  * then multiple DirCacheEntry instances may appear for the same path name.
  */
 public class DirCacheEntry {
+ private static final byte[] nullpad = new byte[8];
+
  // private static final int P_CTIME = 0;
 
  // private static final int P_CTIME_NSEC = 4;
@@ -110,6 +114,77 @@ public class DirCacheEntry {
  in.skip(expLen - actLen);
  }
 
+ void write(final OutputStream os) throws IOException {
+ final int pathLen = path.length;
+ os.write(info, infoOffset, INFO_LEN);
+ os.write(path, 0, pathLen);
+
+ // Index records are padded out to the next 8 byte alignment
+ // for historical reasons related to how C Git read the files.
+ //
+ final int actLen = INFO_LEN + pathLen;
+ final int expLen = (actLen + 8) & ~7;
+ if (actLen != expLen)
+ os.write(nullpad, 0, expLen - actLen);
+ }
+
+ /**
+ * Is it possible for this entry to be accidently assumed clean?
+ * <p>
+ * The "racy git" problem happens when a work file can be updated faster
+ * than the filesystem records file modification timestamps. It is possible
+ * for an application to edit a work file, update the index, then edit it
+ * again before the filesystem will give the work file a new modification
+ * timestamp. This method tests to see if file was written out at the same
+ * time as the index.
+ *
+ * @param smudge_s
+ *            seconds component of the index's last modified time.
+ * @param smudge_ns
+ *            nanoseconds component of the index's last modified time.
+ * @return true if extra careful checks should be used.
+ */
+ final boolean mightBeRacilyClean(final int smudge_s, final int smudge_ns) {
+ // If the index has a modification time then it came from disk
+ // and was not generated from scratch in memory. In such cases
+ // the entry is 'racily clean' if the entry's cached modification
+ // time is equal to or later than the index modification time. In
+ // such cases the work file is too close to the index to tell if
+ // it is clean or not based on the modification time alone.
+ //
+ final int base = infoOffset + P_MTIME;
+ final int mtime = NB.decodeInt32(info, base);
+ if (smudge_s < mtime)
+ return true;
+ if (smudge_s == mtime)
+ return smudge_ns <= NB.decodeInt32(info, base + 4) / 1000000;
+ return false;
+ }
+
+ /**
+ * Force this entry to no longer match its working tree file.
+ * <p>
+ * This avoids the "racy git" problem by making this index entry no longer
+ * match the file in the working directory. Later git will be forced to
+ * compare the file content to ensure the file matches the working tree.
+ */
+ final void smudgeRacilyClean() {
+ // We don't use the same approach as C Git to smudge the entry,
+ // as we cannot compare the working tree file to our SHA-1 and
+ // thus cannot use the "size to 0" trick without accidentally
+ // thinking a zero length file is clean.
+ //
+ // Instead we force the mtime to the largest possible value, so
+ // it is certainly after the index's own modification time and
+ // on a future read will cause mightBeRacilyClean to say "yes!".
+ // It is also unlikely to match with the working tree file.
+ //
+ // I'll see you again before Jan 19, 2038, 03:14:07 AM GMT.
+ //
+ final int base = infoOffset + P_MTIME;
+ Arrays.fill(info, base, base + 8, (byte) 127);
+ }
+
  final byte[] idBuffer() {
  return info;
  }
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 10/26] Support the 'TREE' extension in .git/index through DirCache

Shawn Pearce
We now support reading and writing the 'TREE' extension of the 'DIRC'
file format.  C Git uses this as an optional extension to cache the
SHA-1 id of each tree object used by the index, permitting C Git to
identify subsections of the repository which have not been modified
and to speed up the git-write-tree plumbing command prior to making
a commit object.

Our support includes constructing the tree objects if they do not
exist, but we don't write them to the object database.  This change
only builds the ranges within the index file and marks them invalid,
so C Git knows that the tree must be generated and saved into the
object database before it can rely upon it in a commit.

Like the DirCacheEntry objects we try to avoid unnecessary encode
and decode operations during reads and writes as they would just
drag down the processor.

Our sort ordering of the 'TREE' data is different from that of C Git.
C Git sorts tree children according to lengths of path names, as the
actual order was not relevant but Junio wanted a stable ordering.  We
want our tree children sorted by name so we can merge-sort them onto
the main index entries.  That means we may have to sort the children
after we read them from disk; at least that is true if C Git was the
last process to write the index file.

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../src/org/spearce/jgit/dircache/DirCache.java    |   46 ++
 .../org/spearce/jgit/dircache/DirCacheTree.java    |  453 ++++++++++++++++++++
 2 files changed, 499 insertions(+), 0 deletions(-)
 create mode 100644 org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheTree.java

diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
index 248e2a2..b5fdd46 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
@@ -54,7 +54,9 @@ import org.spearce.jgit.errors.CorruptObjectException;
 import org.spearce.jgit.lib.Constants;
 import org.spearce.jgit.lib.LockFile;
 import org.spearce.jgit.lib.Repository;
+import org.spearce.jgit.util.MutableInteger;
 import org.spearce.jgit.util.NB;
+import org.spearce.jgit.util.TemporaryBuffer;
 
 /**
  * Support for the Git dircache (aka index file).
@@ -72,6 +74,8 @@ import org.spearce.jgit.util.NB;
 public class DirCache {
  private static final byte[] SIG_DIRC = { 'D', 'I', 'R', 'C' };
 
+ private static final int EXT_TREE = 0x54524545 /* 'TREE' */;
+
  private static final int INFO_LEN = DirCacheEntry.INFO_LEN;
 
  private static final DirCacheEntry[] NO_ENTRIES = {};
@@ -211,6 +215,9 @@ public class DirCache {
  /** Number of positions within {@link #sortedEntries} that are valid. */
  private int entryCnt;
 
+ /** Cache tree for this index; null if the cache tree is not available. */
+ private DirCacheTree tree;
+
  /** Our active lock (if we hold it); null if we don't have it locked. */
  private LockFile myLock;
 
@@ -272,6 +279,7 @@ public class DirCache {
  lastModified = 0;
  sortedEntries = NO_ENTRIES;
  entryCnt = 0;
+ tree = null;
  }
 
  private void readFrom(final FileInputStream inStream) throws IOException,
@@ -306,6 +314,12 @@ public class DirCache {
  while (fd.position() - in.available() < sizeOnDisk - 20) {
  NB.readFully(in, hdr, 0, 8);
  switch (NB.decodeInt32(hdr, 0)) {
+ case EXT_TREE: {
+ final byte[] raw = new byte[NB.decodeInt32(hdr, 4)];
+ NB.readFully(in, raw, 0, raw.length);
+ tree = new DirCacheTree(raw, new MutableInteger(), null);
+ break;
+ }
  default:
  if (hdr[0] >= 'A' && hdr[0] <= 'Z') {
  // The extension is optional and is here only as
@@ -417,6 +431,17 @@ public class DirCache {
  }
  }
 
+ if (tree != null) {
+ final TemporaryBuffer bb = new TemporaryBuffer();
+ tree.write(tmp, bb);
+ bb.close();
+
+ NB.encodeInt32(tmp, 0, EXT_TREE);
+ NB.encodeInt32(tmp, 4, (int) bb.length());
+ dos.write(tmp, 0, 8);
+ bb.writeTo(dos, null);
+ }
+
  os.write(foot.digest());
  os.close();
  }
@@ -565,4 +590,25 @@ public class DirCache {
  final int i = findEntry(path);
  return i < 0 ? null : sortedEntries[i];
  }
+
+ /**
+ * Obtain (or build) the current cache tree structure.
+ * <p>
+ * This method can optionally recreate the cache tree, without flushing the
+ * tree objects themselves to disk.
+ *
+ * @param build
+ *            if true and the cache tree is not present in the index it will
+ *            be generated and returned to the caller.
+ * @return the cache tree; null if there is no current cache tree available
+ *         and <code>build</code> was false.
+ */
+ public DirCacheTree getCacheTree(final boolean build) {
+ if (build) {
+ if (tree == null)
+ tree = new DirCacheTree();
+ tree.validate(sortedEntries, entryCnt, 0, 0);
+ }
+ return tree;
+ }
 }
diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheTree.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheTree.java
new file mode 100644
index 0000000..d06be08
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheTree.java
@@ -0,0 +1,453 @@
+/*
+ * Copyright (C) 2008, Shawn O. Pearce <[hidden email]>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.dircache;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.Comparator;
+
+import org.spearce.jgit.lib.Constants;
+import org.spearce.jgit.lib.ObjectId;
+import org.spearce.jgit.util.MutableInteger;
+import org.spearce.jgit.util.RawParseUtils;
+
+/**
+ * Single tree record from the 'TREE' {@link DirCache} extension.
+ * <p>
+ * A valid cache tree record contains the object id of a tree object and the
+ * total number of {@link DirCacheEntry} instances (counted recursively) from
+ * the DirCache contained within the tree. This information facilitates faster
+ * traversal of the index and quicker generation of tree objects prior to
+ * creating a new commit.
+ * <p>
+ * An invalid cache tree record indicates a known subtree whose file entries
+ * have changed in ways that cause the tree to no longer have a known object id.
+ * Invalid cache tree records must be revalidated prior to use.
+ */
+public class DirCacheTree {
+ private static final byte[] NO_NAME = {};
+
+ private static final DirCacheTree[] NO_CHILDREN = {};
+
+ private static final Comparator<DirCacheTree> TREE_CMP = new Comparator<DirCacheTree>() {
+ public int compare(final DirCacheTree o1, final DirCacheTree o2) {
+ final byte[] a = o1.encodedName;
+ final byte[] b = o2.encodedName;
+ final int aLen = a.length;
+ final int bLen = b.length;
+ int cPos;
+ for (cPos = 0; cPos < aLen && cPos < bLen; cPos++) {
+ final int cmp = (a[cPos] & 0xff) - (b[cPos] & 0xff);
+ if (cmp != 0)
+ return cmp;
+ }
+ if (aLen == bLen)
+ return 0;
+ if (aLen < bLen)
+ return '/' - (b[cPos] & 0xff);
+ return (a[cPos] & 0xff) - '/';
+ }
+ };
+
+ /** Tree this tree resides in; null if we are the root. */
+ private DirCacheTree parent;
+
+ /** Name of this tree within its parent. */
+ private byte[] encodedName;
+
+ /** Number of {@link DirCacheEntry} records that belong to this tree. */
+ private int entrySpan;
+
+ /** Unique SHA-1 of this tree; null if invalid. */
+ private ObjectId id;
+
+ /** Child trees, if any, sorted by {@link #encodedName}. */
+ private DirCacheTree[] children;
+
+ /** Number of valid children in {@link #children}. */
+ private int childCnt;
+
+ DirCacheTree() {
+ encodedName = NO_NAME;
+ children = NO_CHILDREN;
+ childCnt = 0;
+ entrySpan = -1;
+ }
+
+ private DirCacheTree(final DirCacheTree myParent, final byte[] path,
+ final int pathOff, final int pathLen) {
+ parent = myParent;
+ encodedName = new byte[pathLen];
+ System.arraycopy(path, pathOff, encodedName, 0, pathLen);
+ children = NO_CHILDREN;
+ childCnt = 0;
+ entrySpan = -1;
+ }
+
+ DirCacheTree(final byte[] in, final MutableInteger off,
+ final DirCacheTree myParent) {
+ parent = myParent;
+
+ int ptr = RawParseUtils.next(in, off.value, '\0');
+ final int nameLen = ptr - off.value - 1;
+ if (nameLen > 0) {
+ encodedName = new byte[nameLen];
+ System.arraycopy(in, off.value, encodedName, 0, nameLen);
+ } else
+ encodedName = NO_NAME;
+
+ entrySpan = RawParseUtils.parseBase10(in, ptr, off);
+ final int subcnt = RawParseUtils.parseBase10(in, off.value, off);
+ off.value = RawParseUtils.next(in, off.value, '\n');
+
+ if (entrySpan >= 0) {
+ // Valid trees have a positive entry count and an id of a
+ // tree object that should exist in the object database.
+ //
+ id = ObjectId.fromRaw(in, off.value);
+ off.value += Constants.OBJECT_ID_LENGTH;
+ }
+
+ if (subcnt > 0) {
+ boolean alreadySorted = true;
+ children = new DirCacheTree[subcnt];
+ for (int i = 0; i < subcnt; i++) {
+ children[i] = new DirCacheTree(in, off, this);
+
+ // C Git's ordering differs from our own; it prefers to
+ // sort by length first. This sometimes produces a sort
+ // we do not desire. On the other hand it may have been
+ // created by us, and be sorted the way we want.
+ //
+ if (alreadySorted && i > 0
+ && TREE_CMP.compare(children[i - 1], children[i]) > 0)
+ alreadySorted = false;
+ }
+ if (!alreadySorted)
+ Arrays.sort(children, 0, subcnt, TREE_CMP);
+ } else {
+ // Leaf level trees have no children, only (file) entries.
+ //
+ children = NO_CHILDREN;
+ }
+ childCnt = subcnt;
+ }
+
+ void write(final byte[] tmp, final OutputStream os) throws IOException {
+ int ptr = tmp.length;
+ tmp[--ptr] = '\n';
+ ptr = RawParseUtils.formatBase10(tmp, ptr, childCnt);
+ tmp[--ptr] = ' ';
+ ptr = RawParseUtils.formatBase10(tmp, ptr, isValid() ? entrySpan : -1);
+ tmp[--ptr] = 0;
+
+ os.write(encodedName);
+ os.write(tmp, ptr, tmp.length - ptr);
+ if (isValid()) {
+ id.copyRawTo(tmp, 0);
+ os.write(tmp, 0, Constants.OBJECT_ID_LENGTH);
+ }
+ for (int i = 0; i < childCnt; i++)
+ children[i].write(tmp, os);
+ }
+
+ /**
+ * Determine if this cache is currently valid.
+ * <p>
+ * A valid cache tree knows how many {@link DirCacheEntry} instances from
+ * the parent {@link DirCache} reside within this tree (recursively
+ * enumerated). It also knows the object id of the tree, as the tree should
+ * be readily available from the repository's object database.
+ *
+ * @return true if this tree is knows key details about itself; false if the
+ *         tree needs to be regenerated.
+ */
+ public boolean isValid() {
+ return id != null;
+ }
+
+ /**
+ * Get the number of entries this tree spans within the DirCache.
+ * <p>
+ * If this tree is not valid (see {@link #isValid()}) this method's return
+ * value is always strictly negative (less than 0) but is otherwise an
+ * undefined result.
+ *
+ * @return total number of entries (recursively) contained within this tree.
+ */
+ public int getEntrySpan() {
+ return entrySpan;
+ }
+
+ /**
+ * Get the number of cached subtrees contained within this tree.
+ *
+ * @return number of child trees available through this tree.
+ */
+ public int getChildCount() {
+ return childCnt;
+ }
+
+ /**
+ * Get the i-th child cache tree.
+ *
+ * @param i
+ *            index of the child to obtain.
+ * @return the child tree.
+ */
+ public DirCacheTree getChild(final int i) {
+ return children[i];
+ }
+
+ ObjectId getObjectId() {
+ return id;
+ }
+
+ /**
+ * Get the tree's name within its parent.
+ * <p>
+ * This method is not very efficient and is primarily meant for debugging
+ * and final output generation. Applications should try to avoid calling it,
+ * and if invoked do so only once per interesting entry, where the name is
+ * absolutely required for correct function.
+ *
+ * @return name of the tree. This does not contain any '/' characters.
+ */
+ public String getNameString() {
+ final ByteBuffer bb = ByteBuffer.wrap(encodedName);
+ return Constants.CHARSET.decode(bb).toString();
+ }
+
+ /**
+ * Get the tree's path within the repository.
+ * <p>
+ * This method is not very efficient and is primarily meant for debugging
+ * and final output generation. Applications should try to avoid calling it,
+ * and if invoked do so only once per interesting entry, where the name is
+ * absolutely required for correct function.
+ *
+ * @return path of the tree, relative to the repository root. If this is not
+ *         the root tree the path ends with '/'. The root tree's path string
+ *         is the empty string ("").
+ */
+ public String getPathString() {
+ final StringBuilder r = new StringBuilder();
+ appendName(r);
+ return r.toString();
+ }
+
+ private void appendName(final StringBuilder r) {
+ if (parent != null) {
+ parent.appendName(r);
+ r.append(getNameString());
+ r.append('/');
+ } else if (nameLength() > 0) {
+ r.append(getNameString());
+ r.append('/');
+ }
+ }
+
+ final int nameLength() {
+ return encodedName.length;
+ }
+
+ final boolean contains(final byte[] a, int aOff, final int aLen) {
+ final byte[] e = encodedName;
+ final int eLen = e.length;
+ for (int eOff = 0; eOff < eLen && aOff < aLen; eOff++, aOff++)
+ if (e[eOff] != a[aOff])
+ return false;
+ if (aOff == aLen)
+ return false;
+ return a[aOff] == '/';
+ }
+
+ /**
+ * Update (if necessary) this tree's entrySpan.
+ *
+ * @param cache
+ *            the complete cache from DirCache.
+ * @param cCnt
+ *            number of entries in <code>cache</code> that are valid for
+ *            iteration.
+ * @param cIdx
+ *            first position of <code>cache</code> that is a member of this
+ *            tree. The path of <code>cache[cacheIdx].path</code> for the
+ *            range <code>[0,pathOff-1)</code> matches the complete path of
+ *            this tree, from the root of the repository.
+ * @param pathOff
+ *            number of bytes of <code>cache[cacheIdx].path</code> that
+ *            matches this tree's path. The value at array position
+ *            <code>cache[cacheIdx].path[pathOff-1]</code> is always '/' if
+ *            <code>pathOff</code> is > 0.
+ */
+ void validate(final DirCacheEntry[] cache, final int cCnt, int cIdx,
+ final int pathOff) {
+ if (entrySpan >= 0) {
+ // If we are valid, our children are also valid.
+ // We have no need to validate them.
+ //
+ return;
+ }
+
+ entrySpan = 0;
+ if (cCnt == 0) {
+ // Special case of an empty index, and we are the root tree.
+ //
+ return;
+ }
+
+ final byte[] firstPath = cache[cIdx].path;
+ int stIdx = 0;
+ while (cIdx < cCnt) {
+ final byte[] currPath = cache[cIdx].path;
+ if (pathOff > 0 && !peq(firstPath, currPath, pathOff)) {
+ // The current entry is no longer in this tree. Our
+ // span is updated and the remainder goes elsewhere.
+ //
+ break;
+ }
+
+ DirCacheTree st = stIdx < childCnt ? children[stIdx] : null;
+ final int cc = namecmp(currPath, pathOff, st);
+ if (cc > 0) {
+ // This subtree is now empty.
+ //
+ removeChild(stIdx);
+ continue;
+ }
+
+ if (cc < 0) {
+ final int p = slash(currPath, pathOff);
+ if (p < 0) {
+ // The entry has no '/' and thus is directly in this
+ // tree. Count it as one of our own.
+ //
+ cIdx++;
+ entrySpan++;
+ continue;
+ }
+
+ // Build a new subtree for this entry.
+ //
+ st = new DirCacheTree(this, currPath, pathOff, p - pathOff);
+ insertChild(stIdx, st);
+ }
+
+ // The entry is contained in this subtree.
+ //
+ st.validate(cache, cCnt, cIdx, pathOff + st.nameLength() + 1);
+ cIdx += st.entrySpan;
+ entrySpan += st.entrySpan;
+ stIdx++;
+ }
+
+ if (stIdx < childCnt) {
+ // None of our remaining children can be in this tree
+ // as the current cache entry is after our own name.
+ //
+ final DirCacheTree[] dct = new DirCacheTree[stIdx];
+ System.arraycopy(children, 0, dct, 0, stIdx);
+ children = dct;
+ }
+ }
+
+ private void insertChild(final int stIdx, final DirCacheTree st) {
+ final DirCacheTree[] c = children;
+ if (childCnt + 1 <= c.length) {
+ if (stIdx < childCnt)
+ System.arraycopy(c, stIdx, c, stIdx + 1, childCnt - stIdx);
+ c[stIdx] = st;
+ childCnt++;
+ return;
+ }
+
+ final int n = c.length;
+ final DirCacheTree[] a = new DirCacheTree[n + 1];
+ if (stIdx > 0)
+ System.arraycopy(c, 0, a, 0, stIdx);
+ a[stIdx] = st;
+ if (stIdx < n)
+ System.arraycopy(c, stIdx, a, stIdx + 1, n - stIdx);
+ children = a;
+ childCnt++;
+ }
+
+ private void removeChild(final int stIdx) {
+ final int n = --childCnt;
+ if (stIdx < n)
+ System.arraycopy(children, stIdx + 1, children, stIdx, n - stIdx);
+ children[n] = null;
+ }
+
+ static boolean peq(final byte[] a, final byte[] b, int aLen) {
+ if (b.length < aLen)
+ return false;
+ for (aLen--; aLen >= 0; aLen--)
+ if (a[aLen] != b[aLen])
+ return false;
+ return true;
+ }
+
+ private static int namecmp(final byte[] a, int aPos, final DirCacheTree ct) {
+ if (ct == null)
+ return -1;
+ final byte[] b = ct.encodedName;
+ final int aLen = a.length;
+ final int bLen = b.length;
+ int bPos = 0;
+ for (; aPos < aLen && bPos < bLen; aPos++, bPos++) {
+ final int cmp = (a[aPos] & 0xff) - (b[bPos] & 0xff);
+ if (cmp != 0)
+ return cmp;
+ }
+ if (bPos == bLen)
+ return a[aPos] == '/' ? 0 : -1;
+ return aLen - bLen;
+ }
+
+ private static int slash(final byte[] a, int aPos) {
+ final int aLen = a.length;
+ for (; aPos < aLen; aPos++)
+ if (a[aPos] == '/')
+ return aPos;
+ return -1;
+ }
+}
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 11/26] Support using a DirCache within a TreeWalk

Shawn Pearce
Being able to include the .git/index file as part of a parallel TreeWalk
which also covers one or more canonical tree objects from the database
and the working directory makes it much easier to handle differences or
merges between the various states.

This iterator implementation adapts a loaded DirCache instance into a
tree structure that the TreeWalk can iterate.  Since TreeWalk wants to
use a hierarchical structure and the DirCache is flat we force the TREE
extension to load (or generate) and work off that.

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../spearce/jgit/dircache/DirCacheIterator.java    |  205 ++++++++++++++++++++
 1 files changed, 205 insertions(+), 0 deletions(-)
 create mode 100644 org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheIterator.java

diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheIterator.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheIterator.java
new file mode 100644
index 0000000..f7ef15d
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheIterator.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (C) 2008, Shawn O. Pearce <[hidden email]>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.dircache;
+
+import java.io.IOException;
+import java.util.Arrays;
+
+import org.spearce.jgit.errors.CorruptObjectException;
+import org.spearce.jgit.errors.IncorrectObjectTypeException;
+import org.spearce.jgit.lib.Constants;
+import org.spearce.jgit.lib.FileMode;
+import org.spearce.jgit.lib.Repository;
+import org.spearce.jgit.treewalk.AbstractTreeIterator;
+
+/**
+ * Iterate a {@link DirCache} as part of a <code>TreeWalk</code>.
+ * <p>
+ * This is an iterator to adapt a loaded <code>DirCache</code> instance (such as
+ * read from an existing <code>.git/index</code> file) to the tree structure
+ * used by a <code>TreeWalk</code>, making it possible for applications to walk
+ * over any combination of tree objects already in the object database, index
+ * files, or working directories.
+ *
+ * @see org.spearce.jgit.treewalk.TreeWalk
+ */
+public class DirCacheIterator extends AbstractTreeIterator {
+ /** The cache this iterator was created to walk. */
+ protected final DirCache cache;
+
+ /** The tree this iterator is walking. */
+ private final DirCacheTree tree;
+
+ /** Special buffer to hold the ObjectId of {@link #currentSubtree}. */
+ private final byte[] subtreeId;
+
+ /** Index of entry within {@link #cache}. */
+ protected int cachePos;
+
+ /** Position of entry within {@link #tree}'s entry span. */
+ private int treePos;
+
+ /** Next subtree to consider within {@link #tree}. */
+ private int subtreeIdx;
+
+ /** The current file entry from {@link #cache}, matching {@link #cachePos}. */
+ protected DirCacheEntry currentEntry;
+
+ /** The subtree containing {@link #currentEntry} if this is first entry. */
+ protected DirCacheTree currentSubtree;
+
+ /**
+ * Create a new iterator for an already loaded DirCache instance.
+ * <p>
+ * The iterator implementation may copy part of the cache's data during
+ * construction, so the cache must be read in prior to creating the
+ * iterator.
+ *
+ * @param dc
+ *            the cache to walk. It must be already loaded into memory.
+ */
+ public DirCacheIterator(final DirCache dc) {
+ cache = dc;
+ tree = dc.getCacheTree(true);
+ subtreeId = new byte[Constants.OBJECT_ID_LENGTH];
+ cachePos = -1;
+ treePos = -1;
+ }
+
+ protected DirCacheIterator(final DirCacheIterator p, final DirCacheTree dct) {
+ super(p, p.path, p.pathLen + 1);
+ cache = p.cache;
+ tree = dct;
+ subtreeId = p.subtreeId;
+ cachePos = p.cachePos - 1; // back up so first next() call enters it
+ treePos = -1;
+ }
+
+ @Override
+ public AbstractTreeIterator createSubtreeIterator(final Repository repo)
+ throws IncorrectObjectTypeException, IOException {
+ if (currentSubtree == null)
+ throw new IncorrectObjectTypeException(getEntryObjectId(),
+ Constants.TYPE_TREE);
+ return new DirCacheIterator(this, currentSubtree);
+ }
+
+ @Override
+ public byte[] idBuffer() {
+ if (currentSubtree != null)
+ return subtreeId;
+ if (currentEntry != null)
+ return currentEntry.idBuffer();
+ return zeroid;
+ }
+
+ @Override
+ public int idOffset() {
+ if (currentSubtree != null)
+ return 0;
+ if (currentEntry != null)
+ return currentEntry.idOffset();
+ return 0;
+ }
+
+ @Override
+ public boolean eof() {
+ return treePos >= tree.getEntrySpan();
+ }
+
+ @Override
+ public void next() throws CorruptObjectException {
+ if (currentSubtree != null) {
+ // If our last position was a subtree we need to skip over
+ // its entire span to get to the item after the subtree.
+ //
+ final int n = currentSubtree.getEntrySpan();
+ cachePos += n;
+ treePos += n;
+ currentSubtree = null;
+ } else {
+ // Our last position was a file/symlink/gitlink, so we
+ // only skip the one entry.
+ //
+ cachePos++;
+ treePos++;
+ }
+
+ if (treePos >= tree.getEntrySpan())
+ return; // this iterator is now at EOF.
+
+ currentEntry = cache.getEntry(cachePos);
+ final byte[] cep = currentEntry.path;
+ if (subtreeIdx < tree.getChildCount()) {
+ final DirCacheTree s = tree.getChild(subtreeIdx);
+ if (s.contains(cep, pathOffset, cep.length)) {
+ // The current position is the first file of this subtree.
+ // Use the subtree instead as the current position.
+ //
+ currentSubtree = s;
+ subtreeIdx++;
+
+ if (s.isValid())
+ s.getObjectId().copyRawTo(subtreeId, 0);
+ else
+ Arrays.fill(subtreeId, (byte) 0);
+ mode = FileMode.TREE.getBits();
+ path = cep;
+ pathLen = pathOffset + s.nameLength();
+ return;
+ }
+ }
+
+ // The current position is a file/symlink/gitlink so we
+ // do not have a subtree located here.
+ //
+ mode = currentEntry.getRawMode();
+ path = cep;
+ pathLen = cep.length;
+ }
+
+ /**
+ * Get the DirCacheEntry for the current file.
+ *
+ * @return the current cache entry, if this iterator is positioned on a
+ *         non-tree.
+ */
+ public DirCacheEntry getDirCacheEntry() {
+ return currentSubtree == null ? currentEntry : null;
+ }
+}
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 12/26] Support recreating a .git/index through DirCache

Shawn Pearce
The DirCacheBuilder is meant for building up a new DirCache content
by iterating through the paths in proper Git sort order.  This is
mostly useful during a TreeWalk, where the paths are being fed to
the application in the correct sort ordering.  Appending them into
the new entry table in order avoids sorting costs later on when we
try to write the file back to disk.

The API is designed for speed, not ease-of-use.  Performing updates
in order and by copying large ranges of the existing index into the
new index is incredibly fast, but requires the application to work
harder to construct the right sequence of calls.

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../spearce/jgit/dircache/BaseDirCacheEditor.java  |  194 ++++++++++++++++++++
 .../src/org/spearce/jgit/dircache/DirCache.java    |   23 +++
 .../org/spearce/jgit/dircache/DirCacheBuilder.java |  173 +++++++++++++++++
 3 files changed, 390 insertions(+), 0 deletions(-)
 create mode 100644 org.spearce.jgit/src/org/spearce/jgit/dircache/BaseDirCacheEditor.java
 create mode 100644 org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheBuilder.java

diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/BaseDirCacheEditor.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/BaseDirCacheEditor.java
new file mode 100644
index 0000000..268c01e
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/BaseDirCacheEditor.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2008, Shawn O. Pearce <[hidden email]>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.dircache;
+
+import java.io.IOException;
+
+/**
+ * Generic update/editing support for {@link DirCache}.
+ * <p>
+ * The different update strategies extend this class to provide their own unique
+ * services to applications.
+ */
+abstract class BaseDirCacheEditor {
+ /** The cache instance this editor updates during {@link #finish()}. */
+ protected DirCache cache;
+
+ /**
+ * Entry table this builder will eventually replace into {@link #cache}.
+ * <p>
+ * Use {@link #fastAdd(DirCacheEntry)} or {@link #fastKeep(int, int)} to
+ * make additions to this table. The table is automatically expanded if it
+ * is too small for a new addition.
+ * <p>
+ * Typically the entries in here are sorted by their path names, just like
+ * they are in the DirCache instance.
+ */
+ protected DirCacheEntry[] entries;
+
+ /** Total number of valid entries in {@link #entries}. */
+ protected int entryCnt;
+
+ /**
+ * Construct a new editor.
+ *
+ * @param dc
+ *            the cache this editor will eventually update.
+ * @param ecnt
+ *            estimated number of entries the editor will have upon
+ *            completion. This sizes the initial entry table.
+ */
+ protected BaseDirCacheEditor(final DirCache dc, final int ecnt) {
+ cache = dc;
+ entries = new DirCacheEntry[ecnt];
+ }
+
+ /**
+ * @return the cache we will update on {@link #finish()}.
+ */
+ public DirCache getDirCache() {
+ return cache;
+ }
+
+ /**
+ * Append one entry into the resulting entry list.
+ * <p>
+ * The entry is placed at the end of the entry list. The caller is
+ * responsible for making sure the final table is correctly sorted.
+ * <p>
+ * The {@link #entries} table is automatically expanded if there is
+ * insufficient space for the new addition.
+ *
+ * @param newEntry
+ *            the new entry to add.
+ */
+ protected void fastAdd(final DirCacheEntry newEntry) {
+ if (entries.length == entryCnt) {
+ final DirCacheEntry[] n = new DirCacheEntry[(entryCnt + 16) * 3 / 2];
+ System.arraycopy(entries, 0, n, 0, entryCnt);
+ entries = n;
+ }
+ entries[entryCnt++] = newEntry;
+ }
+
+ /**
+ * Add a range of existing entries from the destination cache.
+ * <p>
+ * The entries are placed at the end of the entry list, preserving their
+ * current order. The caller is responsible for making sure the final table
+ * is correctly sorted.
+ * <p>
+ * This method copies from the destination cache, which has not yet been
+ * updated with this editor's new table. So all offsets into the destination
+ * cache are not affected by any updates that may be currently taking place
+ * in this editor.
+ * <p>
+ * The {@link #entries} table is automatically expanded if there is
+ * insufficient space for the new additions.
+ *
+ * @param pos
+ *            first entry to copy from the destination cache.
+ * @param cnt
+ *            number of entries to copy.
+ */
+ protected void fastKeep(final int pos, int cnt) {
+ if (entryCnt + cnt > entries.length) {
+ final int m1 = (entryCnt + 16) * 3 / 2;
+ final int m2 = entryCnt + cnt;
+ final DirCacheEntry[] n = new DirCacheEntry[Math.max(m1, m2)];
+ System.arraycopy(entries, 0, n, 0, entryCnt);
+ entries = n;
+ }
+
+ cache.toArray(pos, entries, entryCnt, cnt);
+ entryCnt += cnt;
+ }
+
+ /**
+ * Finish this builder and update the destination {@link DirCache}.
+ * <p>
+ * When this method completes this builder instance is no longer usable by
+ * the calling application. A new builder must be created to make additional
+ * changes to the index entries.
+ * <p>
+ * After completion the DirCache returned by {@link #getDirCache()} will
+ * contain all modifications.
+ * <p>
+ * <i>Note to implementors:</i> Make sure {@link #entries} is fully sorted
+ * then invoke {@link #replace()} to update the DirCache with the new table.
+ */
+ public abstract void finish();
+
+ /**
+ * Update the DirCache with the contents of {@link #entries}.
+ * <p>
+ * This method should be invoked only during an implementation of
+ * {@link #finish()}, and only after {@link #entries} is sorted.
+ */
+ protected void replace() {
+ if (entryCnt < entries.length / 2) {
+ final DirCacheEntry[] n = new DirCacheEntry[entryCnt];
+ System.arraycopy(entries, 0, n, 0, entryCnt);
+ entries = n;
+ }
+ cache.replace(entries, entryCnt);
+ }
+
+ /**
+ * Finish, write, commit this change, and release the index lock.
+ * <p>
+ * If this method fails (returns false) the lock is still released.
+ * <p>
+ * This is a utility method for applications as the finish-write-commit
+ * pattern is very common after using a builder to update entries.
+ *
+ * @return true if the commit was successful and the file contains the new
+ *         data; false if the commit failed and the file remains with the
+ *         old data.
+ * @throws IllegalStateException
+ *             the lock is not held.
+ * @throws IOException
+ *             the output file could not be created. The caller no longer
+ *             holds the lock.
+ */
+ public boolean commit() throws IOException {
+ finish();
+ cache.write();
+ return cache.commit();
+ }
+}
diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
index b5fdd46..810b479 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
@@ -236,6 +236,24 @@ public class DirCache {
  }
 
  /**
+ * Create a new builder to update this cache.
+ * <p>
+ * Callers should add all entries to the builder, then use
+ * {@link DirCacheBuilder#finish()} to update this instance.
+ *
+ * @return a new builder instance for this cache.
+ */
+ public DirCacheBuilder builder() {
+ return new DirCacheBuilder(this, entryCnt + 16);
+ }
+
+ void replace(final DirCacheEntry[] e, final int cnt) {
+ sortedEntries = e;
+ entryCnt = cnt;
+ tree = null;
+ }
+
+ /**
  * Read the index from disk, if it has changed on disk.
  * <p>
  * This method tries to avoid loading the index if it has not changed since
@@ -591,6 +609,11 @@ public class DirCache {
  return i < 0 ? null : sortedEntries[i];
  }
 
+ void toArray(final int i, final DirCacheEntry[] dst, final int off,
+ final int cnt) {
+ System.arraycopy(sortedEntries, i, dst, off, cnt);
+ }
+
  /**
  * Obtain (or build) the current cache tree structure.
  * <p>
diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheBuilder.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheBuilder.java
new file mode 100644
index 0000000..e303b43
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheBuilder.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (C) 2008, Shawn O. Pearce <[hidden email]>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.dircache;
+
+import java.util.Arrays;
+
+/**
+ * Updates a {@link DirCache} by adding individual {@link DirCacheEntry}s.
+ * <p>
+ * A builder always starts from a clean slate and appends in every single
+ * <code>DirCacheEntry</code> which the final updated index must have to reflect
+ * its new content.
+ * <p>
+ * For maximum performance applications should add entries in path name order.
+ * Adding entries out of order is permitted, however a final sorting pass will
+ * be implicitly performed during {@link #finish()} to correct any out-of-order
+ * entries. Duplicate detection is also delayed until the sorting is complete.
+ */
+public class DirCacheBuilder extends BaseDirCacheEditor {
+ private boolean sorted;
+
+ /**
+ * Construct a new builder.
+ *
+ * @param dc
+ *            the cache this builder will eventually update.
+ * @param ecnt
+ *            estimated number of entries the builder will have upon
+ *            completion. This sizes the initial entry table.
+ */
+ protected DirCacheBuilder(final DirCache dc, final int ecnt) {
+ super(dc, ecnt);
+ }
+
+ /**
+ * Append one entry into the resulting entry list.
+ * <p>
+ * The entry is placed at the end of the entry list. If the entry causes the
+ * list to now be incorrectly sorted a final sorting phase will be
+ * automatically enabled within {@link #finish()}.
+ * <p>
+ * The internal entry table is automatically expanded if there is
+ * insufficient space for the new addition.
+ *
+ * @param newEntry
+ *            the new entry to add.
+ */
+ public void add(final DirCacheEntry newEntry) {
+ beforeAdd(newEntry);
+ fastAdd(newEntry);
+ }
+
+ /**
+ * Add a range of existing entries from the destination cache.
+ * <p>
+ * The entries are placed at the end of the entry list. If any of the
+ * entries causes the list to now be incorrectly sorted a final sorting
+ * phase will be automatically enabled within {@link #finish()}.
+ * <p>
+ * This method copies from the destination cache, which has not yet been
+ * updated with this editor's new table. So all offsets into the destination
+ * cache are not affected by any updates that may be currently taking place
+ * in this editor.
+ * <p>
+ * The internal entry table is automatically expanded if there is
+ * insufficient space for the new additions.
+ *
+ * @param pos
+ *            first entry to copy from the destination cache.
+ * @param cnt
+ *            number of entries to copy.
+ */
+ public void keep(final int pos, int cnt) {
+ beforeAdd(cache.getEntry(pos));
+ fastKeep(pos, cnt);
+ }
+
+ public void finish() {
+ if (!sorted)
+ resort();
+ replace();
+ }
+
+ private void beforeAdd(final DirCacheEntry newEntry) {
+ if (sorted && entryCnt > 0) {
+ final DirCacheEntry lastEntry = entries[entryCnt - 1];
+ final int cr = DirCache.cmp(lastEntry, newEntry);
+ if (cr > 0) {
+ // The new entry sorts before the old entry; we are
+ // no longer sorted correctly. We'll need to redo
+ // the sorting before we can close out the build.
+ //
+ sorted = false;
+ } else if (cr == 0) {
+ // Same file path; we can only insert this if the
+ // stages won't be violated.
+ //
+ final int peStage = lastEntry.getStage();
+ final int dceStage = newEntry.getStage();
+ if (peStage == dceStage)
+ throw bad(newEntry, "Duplicate stages not allowed");
+ if (peStage == 0 || dceStage == 0)
+ throw bad(newEntry, "Mixed stages not allowed");
+ if (peStage > dceStage)
+ sorted = false;
+ }
+ }
+ }
+
+ private void resort() {
+ Arrays.sort(entries, 0, entryCnt, DirCache.ENT_CMP);
+
+ for (int entryIdx = 1; entryIdx < entryCnt; entryIdx++) {
+ final DirCacheEntry pe = entries[entryIdx - 1];
+ final DirCacheEntry ce = entries[entryIdx];
+ final int cr = DirCache.cmp(pe, ce);
+ if (cr == 0) {
+ // Same file path; we can only allow this if the stages
+ // are 1-3 and no 0 exists.
+ //
+ final int peStage = pe.getStage();
+ final int ceStage = ce.getStage();
+ if (peStage == ceStage)
+ throw bad(ce, "Duplicate stages not allowed");
+ if (peStage == 0 || ceStage == 0)
+ throw bad(ce, "Mixed stages not allowed");
+ }
+ }
+
+ sorted = true;
+ }
+
+ private static IllegalStateException bad(final DirCacheEntry a,
+ final String msg) {
+ return new IllegalStateException(msg + ": " + a.getStage() + " "
+ + a.getPathString());
+ }
+}
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 13/26] Support iterating and building a DirCache at the same time

Shawn Pearce
This iterator combines the DirCacheBuilder add-in-order update strategy
with a suitable TreeWalk iterator, allowing entries which the TreeWalk
does not return to the application to be automatically carried into the
new index, and the application to handle the entires which the TreeWalk
does return to it.

This can be used to implement a simple "rm" function which removes one
or more paths from the index, while leaving the rest of the index alone.

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../jgit/dircache/DirCacheBuildIterator.java       |  124 ++++++++++++++++++++
 1 files changed, 124 insertions(+), 0 deletions(-)
 create mode 100644 org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheBuildIterator.java

diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheBuildIterator.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheBuildIterator.java
new file mode 100644
index 0000000..ca934ec
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheBuildIterator.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2008, Shawn O. Pearce <[hidden email]>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.dircache;
+
+import java.io.IOException;
+
+import org.spearce.jgit.errors.CorruptObjectException;
+import org.spearce.jgit.errors.IncorrectObjectTypeException;
+import org.spearce.jgit.lib.Constants;
+import org.spearce.jgit.lib.Repository;
+import org.spearce.jgit.treewalk.AbstractTreeIterator;
+
+/**
+ * Iterate and update a {@link DirCache} as part of a <code>TreeWalk</code>.
+ * <p>
+ * Like {@link DirCacheIterator} this iterator allows a DirCache to be used in
+ * parallel with other sorts of iterators in a TreeWalk. However any entry which
+ * appears in the source DirCache and which is skipped by the TreeFilter is
+ * automatically copied into {@link DirCacheBuilder}, thus retaining it in the
+ * newly updated index.
+ * <p>
+ * This iterator is suitable for update processes, or even a simple delete
+ * algorithm. For example deleting a path:
+ *
+ * <pre>
+ * final DirCache dirc = DirCache.lock(db);
+ * final DirCacheBuilder edit = dirc.builder();
+ *
+ * final TreeWalk walk = new TreeWalk(db);
+ * walk.reset();
+ * walk.setRecursive(true);
+ * walk.setFilter(PathFilter.create(&quot;name/to/remove&quot;));
+ * walk.addTree(new DirCacheBuildIterator(edit));
+ *
+ * while (walk.next())
+ * ; // do nothing on a match as we want to remove matches
+ * edit.commit();
+ * </pre>
+ */
+public class DirCacheBuildIterator extends DirCacheIterator {
+ private final DirCacheBuilder builder;
+
+ /**
+ * Create a new iterator for an already loaded DirCache instance.
+ * <p>
+ * The iterator implementation may copy part of the cache's data during
+ * construction, so the cache must be read in prior to creating the
+ * iterator.
+ *
+ * @param dcb
+ *            the cache builder for the cache to walk. The cache must be
+ *            already loaded into memory.
+ */
+ public DirCacheBuildIterator(final DirCacheBuilder dcb) {
+ super(dcb.getDirCache());
+ builder = dcb;
+ }
+
+ protected DirCacheBuildIterator(final DirCacheBuildIterator p,
+ final DirCacheTree dct) {
+ super(p, dct);
+ builder = p.builder;
+ }
+
+ @Override
+ public AbstractTreeIterator createSubtreeIterator(final Repository repo)
+ throws IncorrectObjectTypeException, IOException {
+ if (currentSubtree == null)
+ throw new IncorrectObjectTypeException(getEntryObjectId(),
+ Constants.TYPE_TREE);
+ return new DirCacheBuildIterator(this, currentSubtree);
+ }
+
+ @Override
+ public void skip() throws CorruptObjectException {
+ if (currentSubtree != null)
+ builder.keep(cachePos, currentSubtree.getEntrySpan());
+ else
+ builder.add(currentEntry);
+ next();
+ }
+
+ @Override
+ public void stopWalk() {
+ final int cnt = cache.getEntryCount();
+ if (cachePos < cnt)
+ builder.keep(cachePos, cnt - cachePos);
+ }
+}
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 14/26] Support creating a new DirCacheEntry for an arbitrary path

Shawn Pearce
Applications which use a DirCacheBuilder may need to build their own
DirCacheEntry in order to insert new records into the index file.

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../org/spearce/jgit/dircache/DirCacheEntry.java   |   24 ++++++++++++++++++++
 1 files changed, 24 insertions(+), 0 deletions(-)

diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEntry.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEntry.java
index 8ca8f22..eba2678 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEntry.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEntry.java
@@ -114,6 +114,30 @@ public class DirCacheEntry {
  in.skip(expLen - actLen);
  }
 
+ /**
+ * Create an empty entry.
+ *
+ * @param newPath
+ *            name of the cache entry.
+ */
+ public DirCacheEntry(final String newPath) {
+ this(Constants.encode(newPath));
+ }
+
+ /**
+ * Create an empty entry.
+ *
+ * @param newPath
+ *            name of the cache entry, in the standard encoding.
+ */
+ public DirCacheEntry(final byte[] newPath) {
+ info = new byte[INFO_LEN];
+ infoOffset = 0;
+
+ path = newPath;
+ NB.encodeInt16(info, infoOffset + P_FLAGS, path.length);
+ }
+
  void write(final OutputStream os) throws IOException {
  final int pathLen = path.length;
  os.write(info, infoOffset, INFO_LEN);
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 15/26] Support a simplified model of editing index entries

Shawn Pearce
Some applications may find using DirCacheBuilder difficult and/or just
impossible, as it requires inserting entries in order to have any sort
of good performance.

DirCacheEditor tries to bridge that gap by allowing applications to
insert edit commands out-of-order, then merge-sorts those edits onto
the index entry list from the DirCache.  Since the edit list is likely
to be shorter than the index entry list sorting the edit list and doing
a merge-sort onto the index entry list allows for large range copies in
the regions that are not modified.

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../src/org/spearce/jgit/dircache/DirCache.java    |   22 ++
 .../org/spearce/jgit/dircache/DirCacheBuilder.java |    2 +
 .../org/spearce/jgit/dircache/DirCacheEditor.java  |  265 ++++++++++++++++++++
 3 files changed, 289 insertions(+), 0 deletions(-)
 create mode 100644 org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEditor.java

diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
index 810b479..e48fdec 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
@@ -247,6 +247,18 @@ public class DirCache {
  return new DirCacheBuilder(this, entryCnt + 16);
  }
 
+ /**
+ * Create a new editor to recreate this cache.
+ * <p>
+ * Callers should add commands to the editor, then use
+ * {@link DirCacheEditor#finish()} to update this instance.
+ *
+ * @return a new builder instance for this cache.
+ */
+ public DirCacheEditor editor() {
+ return new DirCacheEditor(this, entryCnt + 16);
+ }
+
  void replace(final DirCacheEntry[] e, final int cnt) {
  sortedEntries = e;
  entryCnt = cnt;
@@ -569,6 +581,16 @@ public class DirCache {
  return nextIdx;
  }
 
+ int nextEntry(final byte[] p, final int pLen, int nextIdx) {
+ while (nextIdx < entryCnt) {
+ final DirCacheEntry next = sortedEntries[nextIdx];
+ if (!DirCacheTree.peq(p, next.path, pLen))
+ break;
+ nextIdx++;
+ }
+ return nextIdx;
+ }
+
  /**
  * Total number of file entries stored in the index.
  * <p>
diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheBuilder.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheBuilder.java
index e303b43..b1d0a1d 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheBuilder.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheBuilder.java
@@ -50,6 +50,8 @@ import java.util.Arrays;
  * Adding entries out of order is permitted, however a final sorting pass will
  * be implicitly performed during {@link #finish()} to correct any out-of-order
  * entries. Duplicate detection is also delayed until the sorting is complete.
+ *
+ * @see DirCacheEditor
  */
 public class DirCacheBuilder extends BaseDirCacheEditor {
  private boolean sorted;
diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEditor.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEditor.java
new file mode 100644
index 0000000..e371d9e
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEditor.java
@@ -0,0 +1,265 @@
+/*
+ * Copyright (C) 2008, Shawn O. Pearce <[hidden email]>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.dircache;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import org.spearce.jgit.lib.Constants;
+
+/**
+ * Updates a {@link DirCache} by supplying discrete edit commands.
+ * <p>
+ * An editor updates a DirCache by taking a list of {@link PathEdit} commands
+ * and executing them against the entries of the destination cache to produce a
+ * new cache. This edit style allows applications to insert a few commands and
+ * then have the editor compute the proper entry indexes necessary to perform an
+ * efficient in-order update of the index records. This can be easier to use
+ * than {@link DirCacheBuilder}.
+ * <p>
+ *
+ * @see DirCacheBuilder
+ */
+public class DirCacheEditor extends BaseDirCacheEditor {
+ private static final Comparator<PathEdit> EDIT_CMP = new Comparator<PathEdit>() {
+ public int compare(final PathEdit o1, final PathEdit o2) {
+ final byte[] a = o1.path;
+ final byte[] b = o2.path;
+ return DirCache.cmp(a, a.length, b, b.length);
+ }
+ };
+
+ private final List<PathEdit> edits;
+
+ /**
+ * Construct a new editor.
+ *
+ * @param dc
+ *            the cache this editor will eventually update.
+ * @param ecnt
+ *            estimated number of entries the editor will have upon
+ *            completion. This sizes the initial entry table.
+ */
+ protected DirCacheEditor(final DirCache dc, final int ecnt) {
+ super(dc, ecnt);
+ edits = new ArrayList<PathEdit>();
+ }
+
+ /**
+ * Append one edit command to the list of commands to be applied.
+ * <p>
+ * Edit commands may be added in any order chosen by the application. They
+ * are automatically rearranged by the builder to provide the most efficient
+ * update possible.
+ *
+ * @param edit
+ *            another edit command.
+ */
+ public void add(final PathEdit edit) {
+ edits.add(edit);
+ }
+
+ @Override
+ public boolean commit() throws IOException {
+ if (edits.isEmpty()) {
+ // No changes? Don't rewrite the index.
+ //
+ cache.unlock();
+ return true;
+ }
+ return super.commit();
+ }
+
+ public void finish() {
+ if (!edits.isEmpty()) {
+ applyEdits();
+ replace();
+ }
+ }
+
+ private void applyEdits() {
+ Collections.sort(edits, EDIT_CMP);
+
+ final int maxIdx = cache.getEntryCount();
+ int lastIdx = 0;
+ for (final PathEdit e : edits) {
+ int eIdx = cache.findEntry(e.path, e.path.length);
+ final boolean missing = eIdx < 0;
+ if (eIdx < 0)
+ eIdx = -(eIdx + 1);
+ final int cnt = Math.min(eIdx, maxIdx) - lastIdx;
+ if (cnt > 0)
+ fastKeep(lastIdx, cnt);
+ lastIdx = missing ? eIdx : cache.nextEntry(eIdx);
+
+ if (e instanceof DeletePath)
+ continue;
+ if (e instanceof DeleteTree) {
+ lastIdx = cache.nextEntry(e.path, e.path.length, eIdx);
+ continue;
+ }
+
+ final DirCacheEntry ent;
+ if (missing)
+ ent = new DirCacheEntry(e.path);
+ else
+ ent = cache.getEntry(eIdx);
+ e.apply(ent);
+ fastAdd(ent);
+ }
+
+ final int cnt = maxIdx - lastIdx;
+ if (cnt > 0)
+ fastKeep(lastIdx, cnt);
+ }
+
+ /**
+ * Any index record update.
+ * <p>
+ * Applications should subclass and provide their own implementation for the
+ * {@link #apply(DirCacheEntry)} method. The editor will invoke apply once
+ * for each record in the index which matches the path name. If there are
+ * multiple records (for example in stages 1, 2 and 3), the edit instance
+ * will be called multiple times, once for each stage.
+ */
+ public abstract static class PathEdit {
+ final byte[] path;
+
+ /**
+ * Create a new update command by path name.
+ *
+ * @param entryPath
+ *            path of the file within the repository.
+ */
+ public PathEdit(final String entryPath) {
+ path = Constants.encode(entryPath);
+ }
+
+ /**
+ * Create a new update command for an existing entry instance.
+ *
+ * @param ent
+ *            entry instance to match path of. Only the path of this
+ *            entry is actually considered during command evaluation.
+ */
+ public PathEdit(final DirCacheEntry ent) {
+ path = ent.path;
+ }
+
+ /**
+ * Apply the update to a single cache entry matching the path.
+ * <p>
+ * After apply is invoked the entry is added to the output table, and
+ * will be included in the new index.
+ *
+ * @param ent
+ *            the entry being processed. All fields are zeroed out if
+ *            the path is a new path in the index.
+ */
+ public abstract void apply(DirCacheEntry ent);
+ }
+
+ /**
+ * Deletes a single file entry from the index.
+ * <p>
+ * This deletion command removes only a single file at the given location,
+ * but removes multiple stages (if present) for that path. To remove a
+ * complete subtree use {@link DeleteTree} instead.
+ *
+ * @see DeleteTree
+ */
+ public static final class DeletePath extends PathEdit {
+ /**
+ * Create a new deletion command by path name.
+ *
+ * @param entryPath
+ *            path of the file within the repository.
+ */
+ public DeletePath(final String entryPath) {
+ super(entryPath);
+ }
+
+ /**
+ * Create a new deletion command for an existing entry instance.
+ *
+ * @param ent
+ *            entry instance to remove. Only the path of this entry is
+ *            actually considered during command evaluation.
+ */
+ public DeletePath(final DirCacheEntry ent) {
+ super(ent);
+ }
+
+ public void apply(final DirCacheEntry ent) {
+ throw new UnsupportedOperationException("No apply in delete");
+ }
+ }
+
+ /**
+ * Recursively deletes all paths under a subtree.
+ * <p>
+ * This deletion command is more generic than {@link DeletePath} as it can
+ * remove all records which appear recursively under the same subtree.
+ * Multiple stages are removed (if present) for any deleted entry.
+ * <p>
+ * This command will not remove a single file entry. To remove a single file
+ * use {@link DeletePath}.
+ *
+ * @see DeletePath
+ */
+ public static final class DeleteTree extends PathEdit {
+ /**
+ * Create a new tree deletion command by path name.
+ *
+ * @param entryPath
+ *            path of the subtree within the repository. If the path
+ *            does not end with "/" a "/" is implicitly added to ensure
+ *            only the subtree's contents are matched by the command.
+ */
+ public DeleteTree(final String entryPath) {
+ super(entryPath.endsWith("/") ? entryPath : entryPath + "/");
+ }
+
+ public void apply(final DirCacheEntry ent) {
+ throw new UnsupportedOperationException("No apply in delete");
+ }
+ }
+}
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 16/26] Support recursively getting all entries under a subtree path

Shawn Pearce
Some applications need to process through all entries of a subtree.
A good example is if the entries need to be recreated into another
subtree to support a "cp -r a b" or "mv a b" operation.

The getEntriesWithin method returns an array of all entries within
a single subtree path, allowing the aplication to process over that
array in order.

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../src/org/spearce/jgit/dircache/DirCache.java    |   22 ++++++++++++++++++++
 1 files changed, 22 insertions(+), 0 deletions(-)

diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
index e48fdec..302c514 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCache.java
@@ -631,6 +631,28 @@ public class DirCache {
  return i < 0 ? null : sortedEntries[i];
  }
 
+ /**
+ * Recursively get all entries within a subtree.
+ *
+ * @param path
+ *            the subtree path to get all entries within.
+ * @return all entries recursively contained within the subtree.
+ */
+ public DirCacheEntry[] getEntriesWithin(String path) {
+ if (!path.endsWith("/"))
+ path += "/";
+ final byte[] p = Constants.encode(path);
+ final int pLen = p.length;
+
+ int eIdx = findEntry(p, pLen);
+ if (eIdx < 0)
+ eIdx = -(eIdx + 1);
+ final int lastIdx = nextEntry(p, pLen, eIdx);
+ final DirCacheEntry[] r = new DirCacheEntry[lastIdx - eIdx];
+ System.arraycopy(sortedEntries, eIdx, r, 0, r.length);
+ return r;
+ }
+
  void toArray(final int i, final DirCacheEntry[] dst, final int off,
  final int cnt) {
  System.arraycopy(sortedEntries, i, dst, off, cnt);
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 17/26] Support copying meta fields from one DirCacheEntry to another

Shawn Pearce
When an application moves a DirCacheEntry record from one path to
another path in the index we need to recreate the entry object and
also copy the meta fields from the old entry to the new entry.

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../org/spearce/jgit/dircache/DirCacheEntry.java   |   16 ++++++++++++++++
 1 files changed, 16 insertions(+), 0 deletions(-)

diff --git a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEntry.java b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEntry.java
index eba2678..2b5ce03 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEntry.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/dircache/DirCacheEntry.java
@@ -354,6 +354,22 @@ public class DirCacheEntry {
  return Constants.CHARSET.decode(ByteBuffer.wrap(path)).toString();
  }
 
+ /**
+ * Copy the ObjectId and other meta fields from an existing entry.
+ * <p>
+ * This method copies everything except the path from one entry to another,
+ * supporting renaming.
+ *
+ * @param src
+ *            the entry to copy ObjectId and meta fields from.
+ */
+ public void copyMetaData(final DirCacheEntry src) {
+ final int pLen = NB.decodeUInt16(info, infoOffset + P_FLAGS) & 0xfff;
+ System.arraycopy(src.info, src.infoOffset, info, infoOffset, INFO_LEN);
+ NB.encodeInt16(info, infoOffset + P_FLAGS, pLen
+ | NB.decodeUInt16(info, infoOffset + P_FLAGS) & ~0xfff);
+ }
+
  private long decodeTS(final int pIdx) {
  final int base = infoOffset + pIdx;
  final int sec = NB.decodeInt32(info, base);
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 18/26] Add JUnit tests for new DirCache API

Shawn Pearce
These tests excerise the file reading and writing routines, as well as
the two forms of editing the cache (through builder and editor).

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../spearce/jgit/dircache/DirCacheBasicTest.java   |  185 +++++++++++++
 .../jgit/dircache/DirCacheBuilderIteratorTest.java |   91 +++++++
 .../spearce/jgit/dircache/DirCacheBuilderTest.java |  253 ++++++++++++++++++
 .../spearce/jgit/dircache/DirCacheFindTest.java    |   86 ++++++
 .../jgit/dircache/DirCacheIteratorTest.java        |  273 ++++++++++++++++++++
 .../spearce/jgit/dircache/DirCacheTreeTest.java    |  150 +++++++++++
 6 files changed, 1038 insertions(+), 0 deletions(-)
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheBasicTest.java
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheBuilderIteratorTest.java
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheBuilderTest.java
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheFindTest.java
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheIteratorTest.java
 create mode 100644 org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheTreeTest.java

diff --git a/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheBasicTest.java b/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheBasicTest.java
new file mode 100644
index 0000000..b3097ac
--- /dev/null
+++ b/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheBasicTest.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright (C) 2008, Google Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.dircache;
+
+import java.io.File;
+
+import org.spearce.jgit.lib.RepositoryTestCase;
+
+public class DirCacheBasicTest extends RepositoryTestCase {
+ public void testReadMissing_RealIndex() throws Exception {
+ final File idx = new File(db.getDirectory(), "index");
+ assertFalse(idx.exists());
+
+ final DirCache dc = DirCache.read(db);
+ assertNotNull(dc);
+ assertEquals(0, dc.getEntryCount());
+ }
+
+ public void testReadMissing_TempIndex() throws Exception {
+ final File idx = new File(db.getDirectory(), "tmp_index");
+ assertFalse(idx.exists());
+
+ final DirCache dc = DirCache.read(idx);
+ assertNotNull(dc);
+ assertEquals(0, dc.getEntryCount());
+ }
+
+ public void testLockMissing_RealIndex() throws Exception {
+ final File idx = new File(db.getDirectory(), "index");
+ final File lck = new File(db.getDirectory(), "index.lock");
+ assertFalse(idx.exists());
+ assertFalse(lck.exists());
+
+ final DirCache dc = DirCache.lock(db);
+ assertNotNull(dc);
+ assertFalse(idx.exists());
+ assertTrue(lck.exists());
+ assertEquals(0, dc.getEntryCount());
+
+ dc.unlock();
+ assertFalse(idx.exists());
+ assertFalse(lck.exists());
+ }
+
+ public void testLockMissing_TempIndex() throws Exception {
+ final File idx = new File(db.getDirectory(), "tmp_index");
+ final File lck = new File(db.getDirectory(), "tmp_index.lock");
+ assertFalse(idx.exists());
+ assertFalse(lck.exists());
+
+ final DirCache dc = DirCache.lock(idx);
+ assertNotNull(dc);
+ assertFalse(idx.exists());
+ assertTrue(lck.exists());
+ assertEquals(0, dc.getEntryCount());
+
+ dc.unlock();
+ assertFalse(idx.exists());
+ assertFalse(lck.exists());
+ }
+
+ public void testWriteEmptyUnlock_RealIndex() throws Exception {
+ final File idx = new File(db.getDirectory(), "index");
+ final File lck = new File(db.getDirectory(), "index.lock");
+ assertFalse(idx.exists());
+ assertFalse(lck.exists());
+
+ final DirCache dc = DirCache.lock(db);
+ assertEquals(0, lck.length());
+ dc.write();
+ assertEquals(12 + 20, lck.length());
+
+ dc.unlock();
+ assertFalse(idx.exists());
+ assertFalse(lck.exists());
+ }
+
+ public void testWriteEmptyCommit_RealIndex() throws Exception {
+ final File idx = new File(db.getDirectory(), "index");
+ final File lck = new File(db.getDirectory(), "index.lock");
+ assertFalse(idx.exists());
+ assertFalse(lck.exists());
+
+ final DirCache dc = DirCache.lock(db);
+ assertEquals(0, lck.length());
+ dc.write();
+ assertEquals(12 + 20, lck.length());
+
+ assertTrue(dc.commit());
+ assertTrue(idx.exists());
+ assertFalse(lck.exists());
+ assertEquals(12 + 20, idx.length());
+ }
+
+ public void testWriteEmptyReadEmpty_RealIndex() throws Exception {
+ final File idx = new File(db.getDirectory(), "index");
+ final File lck = new File(db.getDirectory(), "index.lock");
+ assertFalse(idx.exists());
+ assertFalse(lck.exists());
+ {
+ final DirCache dc = DirCache.lock(db);
+ dc.write();
+ assertTrue(dc.commit());
+ assertTrue(idx.exists());
+ }
+ {
+ final DirCache dc = DirCache.read(db);
+ assertEquals(0, dc.getEntryCount());
+ }
+ }
+
+ public void testWriteEmptyLockEmpty_RealIndex() throws Exception {
+ final File idx = new File(db.getDirectory(), "index");
+ final File lck = new File(db.getDirectory(), "index.lock");
+ assertFalse(idx.exists());
+ assertFalse(lck.exists());
+ {
+ final DirCache dc = DirCache.lock(db);
+ dc.write();
+ assertTrue(dc.commit());
+ assertTrue(idx.exists());
+ }
+ {
+ final DirCache dc = DirCache.lock(db);
+ assertEquals(0, dc.getEntryCount());
+ assertTrue(idx.exists());
+ assertTrue(lck.exists());
+ dc.unlock();
+ }
+ }
+
+ public void testBuildThenClear() throws Exception {
+ final DirCache dc = DirCache.read(db);
+
+ final String[] paths = { "a.", "a.b", "a/b", "a0b" };
+ final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
+ for (int i = 0; i < paths.length; i++)
+ ents[i] = new DirCacheEntry(paths[i]);
+
+ final DirCacheBuilder b = dc.builder();
+ for (int i = 0; i < ents.length; i++)
+ b.add(ents[i]);
+ b.finish();
+
+ assertEquals(paths.length, dc.getEntryCount());
+ dc.clear();
+ assertEquals(0, dc.getEntryCount());
+ }
+
+}
diff --git a/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheBuilderIteratorTest.java b/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheBuilderIteratorTest.java
new file mode 100644
index 0000000..cbcdeb5
--- /dev/null
+++ b/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheBuilderIteratorTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2008, Google Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.dircache;
+
+import java.util.Collections;
+
+import org.spearce.jgit.lib.FileMode;
+import org.spearce.jgit.lib.RepositoryTestCase;
+import org.spearce.jgit.treewalk.TreeWalk;
+import org.spearce.jgit.treewalk.filter.PathFilterGroup;
+
+public class DirCacheBuilderIteratorTest extends RepositoryTestCase {
+ public void testPathFilterGroup_DoesNotSkipTail() throws Exception {
+ final DirCache dc = DirCache.read(db);
+
+ final FileMode mode = FileMode.REGULAR_FILE;
+ final String[] paths = { "a.", "a/b", "a/c", "a/d", "a0b" };
+ final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
+ for (int i = 0; i < paths.length; i++) {
+ ents[i] = new DirCacheEntry(paths[i]);
+ ents[i].setFileMode(mode);
+ }
+ {
+ final DirCacheBuilder b = dc.builder();
+ for (int i = 0; i < ents.length; i++)
+ b.add(ents[i]);
+ b.finish();
+ }
+
+ final int expIdx = 2;
+ final DirCacheBuilder b = dc.builder();
+ final TreeWalk tw = new TreeWalk(db);
+ tw.reset();
+ tw.addTree(new DirCacheBuildIterator(b));
+ tw.setRecursive(true);
+ tw.setFilter(PathFilterGroup.createFromStrings(Collections
+ .singleton(paths[expIdx])));
+
+ assertTrue("found " + paths[expIdx], tw.next());
+ final DirCacheIterator c = tw.getTree(0, DirCacheIterator.class);
+ assertNotNull(c);
+ assertEquals(expIdx, c.cachePos);
+ assertSame(ents[expIdx], c.getDirCacheEntry());
+ assertEquals(paths[expIdx], tw.getPathString());
+ assertEquals(mode.getBits(), tw.getRawMode(0));
+ assertSame(mode, tw.getFileMode(0));
+ b.add(c.getDirCacheEntry());
+
+ assertFalse("no more entries", tw.next());
+
+ b.finish();
+ assertEquals(ents.length, dc.getEntryCount());
+ for (int i = 0; i < ents.length; i++)
+ assertSame(ents[i], dc.getEntry(i));
+ }
+}
diff --git a/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheBuilderTest.java b/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheBuilderTest.java
new file mode 100644
index 0000000..2cf1d92
--- /dev/null
+++ b/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheBuilderTest.java
@@ -0,0 +1,253 @@
+/*
+ * Copyright (C) 2008, Google Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.dircache;
+
+import java.io.File;
+
+import org.spearce.jgit.lib.FileMode;
+import org.spearce.jgit.lib.ObjectId;
+import org.spearce.jgit.lib.RepositoryTestCase;
+
+public class DirCacheBuilderTest extends RepositoryTestCase {
+ public void testBuildEmpty() throws Exception {
+ {
+ final DirCache dc = DirCache.lock(db);
+ final DirCacheBuilder b = dc.builder();
+ assertNotNull(b);
+ b.finish();
+ dc.write();
+ assertTrue(dc.commit());
+ }
+ {
+ final DirCache dc = DirCache.read(db);
+ assertEquals(0, dc.getEntryCount());
+ }
+ }
+
+ public void testBuildOneFile_FinishWriteCommit() throws Exception {
+ final String path = "a-file-path";
+ final FileMode mode = FileMode.REGULAR_FILE;
+ final long lastModified = 1218123387057L;
+ final int length = 1342;
+ final DirCacheEntry entOrig;
+ {
+ final DirCache dc = DirCache.lock(db);
+ final DirCacheBuilder b = dc.builder();
+ assertNotNull(b);
+
+ entOrig = new DirCacheEntry(path);
+ entOrig.setFileMode(mode);
+ entOrig.setLastModified(lastModified);
+ entOrig.setLength(length);
+
+ assertNotSame(path, entOrig.getPathString());
+ assertEquals(path, entOrig.getPathString());
+ assertEquals(ObjectId.zeroId(), entOrig.getObjectId());
+ assertEquals(mode.getBits(), entOrig.getRawMode());
+ assertEquals(0, entOrig.getStage());
+ assertEquals(lastModified, entOrig.getLastModified());
+ assertEquals(length, entOrig.getLength());
+ assertFalse(entOrig.isAssumeValid());
+ b.add(entOrig);
+
+ b.finish();
+ assertEquals(1, dc.getEntryCount());
+ assertSame(entOrig, dc.getEntry(0));
+
+ dc.write();
+ assertTrue(dc.commit());
+ }
+ {
+ final DirCache dc = DirCache.read(db);
+ assertEquals(1, dc.getEntryCount());
+
+ final DirCacheEntry entRead = dc.getEntry(0);
+ assertNotSame(entOrig, entRead);
+ assertEquals(path, entRead.getPathString());
+ assertEquals(ObjectId.zeroId(), entOrig.getObjectId());
+ assertEquals(mode.getBits(), entOrig.getRawMode());
+ assertEquals(0, entOrig.getStage());
+ assertEquals(lastModified, entOrig.getLastModified());
+ assertEquals(length, entOrig.getLength());
+ assertFalse(entOrig.isAssumeValid());
+ }
+ }
+
+ public void testBuildOneFile_Commit() throws Exception {
+ final String path = "a-file-path";
+ final FileMode mode = FileMode.REGULAR_FILE;
+ final long lastModified = 1218123387057L;
+ final int length = 1342;
+ final DirCacheEntry entOrig;
+ {
+ final DirCache dc = DirCache.lock(db);
+ final DirCacheBuilder b = dc.builder();
+ assertNotNull(b);
+
+ entOrig = new DirCacheEntry(path);
+ entOrig.setFileMode(mode);
+ entOrig.setLastModified(lastModified);
+ entOrig.setLength(length);
+
+ assertNotSame(path, entOrig.getPathString());
+ assertEquals(path, entOrig.getPathString());
+ assertEquals(ObjectId.zeroId(), entOrig.getObjectId());
+ assertEquals(mode.getBits(), entOrig.getRawMode());
+ assertEquals(0, entOrig.getStage());
+ assertEquals(lastModified, entOrig.getLastModified());
+ assertEquals(length, entOrig.getLength());
+ assertFalse(entOrig.isAssumeValid());
+ b.add(entOrig);
+
+ assertTrue(b.commit());
+ assertEquals(1, dc.getEntryCount());
+ assertSame(entOrig, dc.getEntry(0));
+ assertFalse(new File(db.getDirectory(), "index.lock").exists());
+ }
+ {
+ final DirCache dc = DirCache.read(db);
+ assertEquals(1, dc.getEntryCount());
+
+ final DirCacheEntry entRead = dc.getEntry(0);
+ assertNotSame(entOrig, entRead);
+ assertEquals(path, entRead.getPathString());
+ assertEquals(ObjectId.zeroId(), entOrig.getObjectId());
+ assertEquals(mode.getBits(), entOrig.getRawMode());
+ assertEquals(0, entOrig.getStage());
+ assertEquals(lastModified, entOrig.getLastModified());
+ assertEquals(length, entOrig.getLength());
+ assertFalse(entOrig.isAssumeValid());
+ }
+ }
+
+ public void testFindSingleFile() throws Exception {
+ final String path = "a-file-path";
+ final DirCache dc = DirCache.read(db);
+ final DirCacheBuilder b = dc.builder();
+ assertNotNull(b);
+
+ final DirCacheEntry entOrig = new DirCacheEntry(path);
+ assertNotSame(path, entOrig.getPathString());
+ assertEquals(path, entOrig.getPathString());
+ b.add(entOrig);
+ b.finish();
+
+ assertEquals(1, dc.getEntryCount());
+ assertSame(entOrig, dc.getEntry(0));
+ assertEquals(0, dc.findEntry(path));
+
+ assertEquals(-1, dc.findEntry("@@-before"));
+ assertEquals(0, real(dc.findEntry("@@-before")));
+
+ assertEquals(-2, dc.findEntry("a-zoo"));
+ assertEquals(1, real(dc.findEntry("a-zoo")));
+
+ assertSame(entOrig, dc.getEntry(path));
+ }
+
+ public void testAdd_InGitSortOrder() throws Exception {
+ final DirCache dc = DirCache.read(db);
+
+ final String[] paths = { "a.", "a.b", "a/b", "a0b" };
+ final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
+ for (int i = 0; i < paths.length; i++)
+ ents[i] = new DirCacheEntry(paths[i]);
+
+ final DirCacheBuilder b = dc.builder();
+ for (int i = 0; i < ents.length; i++)
+ b.add(ents[i]);
+ b.finish();
+
+ assertEquals(paths.length, dc.getEntryCount());
+ for (int i = 0; i < paths.length; i++) {
+ assertSame(ents[i], dc.getEntry(i));
+ assertEquals(paths[i], dc.getEntry(i).getPathString());
+ assertEquals(i, dc.findEntry(paths[i]));
+ assertSame(ents[i], dc.getEntry(paths[i]));
+ }
+ }
+
+ public void testAdd_ReverseGitSortOrder() throws Exception {
+ final DirCache dc = DirCache.read(db);
+
+ final String[] paths = { "a.", "a.b", "a/b", "a0b" };
+ final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
+ for (int i = 0; i < paths.length; i++)
+ ents[i] = new DirCacheEntry(paths[i]);
+
+ final DirCacheBuilder b = dc.builder();
+ for (int i = ents.length - 1; i >= 0; i--)
+ b.add(ents[i]);
+ b.finish();
+
+ assertEquals(paths.length, dc.getEntryCount());
+ for (int i = 0; i < paths.length; i++) {
+ assertSame(ents[i], dc.getEntry(i));
+ assertEquals(paths[i], dc.getEntry(i).getPathString());
+ assertEquals(i, dc.findEntry(paths[i]));
+ assertSame(ents[i], dc.getEntry(paths[i]));
+ }
+ }
+
+ public void testBuilderClear() throws Exception {
+ final DirCache dc = DirCache.read(db);
+
+ final String[] paths = { "a.", "a.b", "a/b", "a0b" };
+ final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
+ for (int i = 0; i < paths.length; i++)
+ ents[i] = new DirCacheEntry(paths[i]);
+ {
+ final DirCacheBuilder b = dc.builder();
+ for (int i = 0; i < ents.length; i++)
+ b.add(ents[i]);
+ b.finish();
+ }
+ assertEquals(paths.length, dc.getEntryCount());
+ {
+ final DirCacheBuilder b = dc.builder();
+ b.finish();
+ }
+ assertEquals(0, dc.getEntryCount());
+ }
+
+ private static int real(int eIdx) {
+ if (eIdx < 0)
+ eIdx = -(eIdx + 1);
+ return eIdx;
+ }
+}
diff --git a/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheFindTest.java b/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheFindTest.java
new file mode 100644
index 0000000..0eb0302
--- /dev/null
+++ b/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheFindTest.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2008, Google Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.dircache;
+
+import org.spearce.jgit.lib.RepositoryTestCase;
+
+public class DirCacheFindTest extends RepositoryTestCase {
+ public void testEntriesWithin() throws Exception {
+ final DirCache dc = DirCache.read(db);
+
+ final String[] paths = { "a.", "a/b", "a/c", "a/d", "a0b" };
+ final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
+ for (int i = 0; i < paths.length; i++)
+ ents[i] = new DirCacheEntry(paths[i]);
+ final int aFirst = 1;
+ final int aLast = 3;
+
+ final DirCacheBuilder b = dc.builder();
+ for (int i = 0; i < ents.length; i++)
+ b.add(ents[i]);
+ b.finish();
+
+ assertEquals(paths.length, dc.getEntryCount());
+ for (int i = 0; i < ents.length; i++)
+ assertSame(ents[i], dc.getEntry(i));
+
+ {
+ final DirCacheEntry[] aContents = dc.getEntriesWithin("a");
+ assertNotNull(aContents);
+ assertEquals(aLast - aFirst + 1, aContents.length);
+ for (int i = aFirst, j = 0; i <= aLast; i++, j++)
+ assertSame(ents[i], aContents[j]);
+ }
+ {
+ final DirCacheEntry[] aContents = dc.getEntriesWithin("a/");
+ assertNotNull(aContents);
+ assertEquals(aLast - aFirst + 1, aContents.length);
+ for (int i = aFirst, j = 0; i <= aLast; i++, j++)
+ assertSame(ents[i], aContents[j]);
+ }
+
+ assertNotNull(dc.getEntriesWithin("a."));
+ assertEquals(0, dc.getEntriesWithin("a.").length);
+
+ assertNotNull(dc.getEntriesWithin("a0b"));
+ assertEquals(0, dc.getEntriesWithin("a0b.").length);
+
+ assertNotNull(dc.getEntriesWithin("zoo"));
+ assertEquals(0, dc.getEntriesWithin("zoo.").length);
+ }
+}
diff --git a/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheIteratorTest.java b/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheIteratorTest.java
new file mode 100644
index 0000000..7d4e6bb
--- /dev/null
+++ b/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheIteratorTest.java
@@ -0,0 +1,273 @@
+/*
+ * Copyright (C) 2008, Google Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.dircache;
+
+import java.util.Collections;
+
+import org.spearce.jgit.lib.FileMode;
+import org.spearce.jgit.lib.RepositoryTestCase;
+import org.spearce.jgit.treewalk.TreeWalk;
+import org.spearce.jgit.treewalk.filter.PathFilterGroup;
+
+public class DirCacheIteratorTest extends RepositoryTestCase {
+ public void testEmptyTree_NoTreeWalk() throws Exception {
+ final DirCache dc = DirCache.read(db);
+ assertEquals(0, dc.getEntryCount());
+
+ final DirCacheIterator i = new DirCacheIterator(dc);
+ i.next();
+ assertTrue(i.eof());
+ }
+
+ public void testEmptyTree_WithTreeWalk() throws Exception {
+ final DirCache dc = DirCache.read(db);
+ assertEquals(0, dc.getEntryCount());
+
+ final TreeWalk tw = new TreeWalk(db);
+ tw.reset();
+ tw.addTree(new DirCacheIterator(dc));
+ assertFalse(tw.next());
+ }
+
+ public void testNoSubtree_NoTreeWalk() throws Exception {
+ final DirCache dc = DirCache.read(db);
+
+ final String[] paths = { "a.", "a0b" };
+ final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
+ for (int i = 0; i < paths.length; i++)
+ ents[i] = new DirCacheEntry(paths[i]);
+
+ final DirCacheBuilder b = dc.builder();
+ for (int i = 0; i < ents.length; i++)
+ b.add(ents[i]);
+ b.finish();
+
+ final DirCacheIterator i = new DirCacheIterator(dc);
+ int pathIdx = 0;
+ for (;;) {
+ i.next();
+ if (i.eof())
+ break;
+ assertEquals(pathIdx, i.cachePos);
+ assertSame(ents[pathIdx], i.getDirCacheEntry());
+ pathIdx++;
+ }
+ assertEquals(pathIdx, paths.length);
+ }
+
+ public void testNoSubtree_WithTreeWalk() throws Exception {
+ final DirCache dc = DirCache.read(db);
+
+ final String[] paths = { "a.", "a0b" };
+ final FileMode[] modes = { FileMode.EXECUTABLE_FILE, FileMode.GITLINK };
+ final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
+ for (int i = 0; i < paths.length; i++) {
+ ents[i] = new DirCacheEntry(paths[i]);
+ ents[i].setFileMode(modes[i]);
+ }
+
+ final DirCacheBuilder b = dc.builder();
+ for (int i = 0; i < ents.length; i++)
+ b.add(ents[i]);
+ b.finish();
+
+ final DirCacheIterator i = new DirCacheIterator(dc);
+ final TreeWalk tw = new TreeWalk(db);
+ tw.reset();
+ tw.addTree(i);
+ int pathIdx = 0;
+ while (tw.next()) {
+ assertSame(i, tw.getTree(0, DirCacheIterator.class));
+ assertEquals(pathIdx, i.cachePos);
+ assertSame(ents[pathIdx], i.getDirCacheEntry());
+ assertEquals(paths[pathIdx], tw.getPathString());
+ assertEquals(modes[pathIdx].getBits(), tw.getRawMode(0));
+ assertSame(modes[pathIdx], tw.getFileMode(0));
+ pathIdx++;
+ }
+ assertEquals(pathIdx, paths.length);
+ }
+
+ public void testSingleSubtree_NoRecursion() throws Exception {
+ final DirCache dc = DirCache.read(db);
+
+ final String[] paths = { "a.", "a/b", "a/c", "a/d", "a0b" };
+ final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
+ for (int i = 0; i < paths.length; i++) {
+ ents[i] = new DirCacheEntry(paths[i]);
+ ents[i].setFileMode(FileMode.REGULAR_FILE);
+ }
+
+ final DirCacheBuilder b = dc.builder();
+ for (int i = 0; i < ents.length; i++)
+ b.add(ents[i]);
+ b.finish();
+
+ final String[] expPaths = { "a.", "a", "a0b" };
+ final FileMode[] expModes = { FileMode.REGULAR_FILE, FileMode.TREE,
+ FileMode.REGULAR_FILE };
+ final int expPos[] = { 0, -1, 4 };
+
+ final DirCacheIterator i = new DirCacheIterator(dc);
+ final TreeWalk tw = new TreeWalk(db);
+ tw.reset();
+ tw.addTree(i);
+ tw.setRecursive(false);
+ int pathIdx = 0;
+ while (tw.next()) {
+ assertSame(i, tw.getTree(0, DirCacheIterator.class));
+ assertEquals(expModes[pathIdx].getBits(), tw.getRawMode(0));
+ assertSame(expModes[pathIdx], tw.getFileMode(0));
+ assertEquals(expPaths[pathIdx], tw.getPathString());
+
+ if (expPos[pathIdx] >= 0) {
+ assertEquals(expPos[pathIdx], i.cachePos);
+ assertSame(ents[expPos[pathIdx]], i.getDirCacheEntry());
+ } else {
+ assertSame(FileMode.TREE, tw.getFileMode(0));
+ }
+
+ pathIdx++;
+ }
+ assertEquals(pathIdx, expPaths.length);
+ }
+
+ public void testSingleSubtree_Recursive() throws Exception {
+ final DirCache dc = DirCache.read(db);
+
+ final FileMode mode = FileMode.REGULAR_FILE;
+ final String[] paths = { "a.", "a/b", "a/c", "a/d", "a0b" };
+ final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
+ for (int i = 0; i < paths.length; i++) {
+ ents[i] = new DirCacheEntry(paths[i]);
+ ents[i].setFileMode(mode);
+ }
+
+ final DirCacheBuilder b = dc.builder();
+ for (int i = 0; i < ents.length; i++)
+ b.add(ents[i]);
+ b.finish();
+
+ final DirCacheIterator i = new DirCacheIterator(dc);
+ final TreeWalk tw = new TreeWalk(db);
+ tw.reset();
+ tw.addTree(i);
+ tw.setRecursive(true);
+ int pathIdx = 0;
+ while (tw.next()) {
+ final DirCacheIterator c = tw.getTree(0, DirCacheIterator.class);
+ assertNotNull(c);
+ assertEquals(pathIdx, c.cachePos);
+ assertSame(ents[pathIdx], c.getDirCacheEntry());
+ assertEquals(paths[pathIdx], tw.getPathString());
+ assertEquals(mode.getBits(), tw.getRawMode(0));
+ assertSame(mode, tw.getFileMode(0));
+ pathIdx++;
+ }
+ assertEquals(pathIdx, paths.length);
+ }
+
+ public void testTwoLevelSubtree_Recursive() throws Exception {
+ final DirCache dc = DirCache.read(db);
+
+ final FileMode mode = FileMode.REGULAR_FILE;
+ final String[] paths = { "a.", "a/b", "a/c/e", "a/c/f", "a/d", "a0b" };
+ final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
+ for (int i = 0; i < paths.length; i++) {
+ ents[i] = new DirCacheEntry(paths[i]);
+ ents[i].setFileMode(mode);
+ }
+
+ final DirCacheBuilder b = dc.builder();
+ for (int i = 0; i < ents.length; i++)
+ b.add(ents[i]);
+ b.finish();
+
+ final TreeWalk tw = new TreeWalk(db);
+ tw.reset();
+ tw.addTree(new DirCacheIterator(dc));
+ tw.setRecursive(true);
+ int pathIdx = 0;
+ while (tw.next()) {
+ final DirCacheIterator c = tw.getTree(0, DirCacheIterator.class);
+ assertNotNull(c);
+ assertEquals(pathIdx, c.cachePos);
+ assertSame(ents[pathIdx], c.getDirCacheEntry());
+ assertEquals(paths[pathIdx], tw.getPathString());
+ assertEquals(mode.getBits(), tw.getRawMode(0));
+ assertSame(mode, tw.getFileMode(0));
+ pathIdx++;
+ }
+ assertEquals(pathIdx, paths.length);
+ }
+
+ public void testTwoLevelSubtree_FilterPath() throws Exception {
+ final DirCache dc = DirCache.read(db);
+
+ final FileMode mode = FileMode.REGULAR_FILE;
+ final String[] paths = { "a.", "a/b", "a/c/e", "a/c/f", "a/d", "a0b" };
+ final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
+ for (int i = 0; i < paths.length; i++) {
+ ents[i] = new DirCacheEntry(paths[i]);
+ ents[i].setFileMode(mode);
+ }
+
+ final DirCacheBuilder b = dc.builder();
+ for (int i = 0; i < ents.length; i++)
+ b.add(ents[i]);
+ b.finish();
+
+ final TreeWalk tw = new TreeWalk(db);
+ for (int victimIdx = 0; victimIdx < paths.length; victimIdx++) {
+ tw.reset();
+ tw.addTree(new DirCacheIterator(dc));
+ tw.setFilter(PathFilterGroup.createFromStrings(Collections
+ .singleton(paths[victimIdx])));
+ tw.setRecursive(tw.getFilter().shouldBeRecursive());
+ assertTrue(tw.next());
+ final DirCacheIterator c = tw.getTree(0, DirCacheIterator.class);
+ assertNotNull(c);
+ assertEquals(victimIdx, c.cachePos);
+ assertSame(ents[victimIdx], c.getDirCacheEntry());
+ assertEquals(paths[victimIdx], tw.getPathString());
+ assertEquals(mode.getBits(), tw.getRawMode(0));
+ assertSame(mode, tw.getFileMode(0));
+ assertFalse(tw.next());
+ }
+ }
+}
diff --git a/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheTreeTest.java b/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheTreeTest.java
new file mode 100644
index 0000000..b37095d
--- /dev/null
+++ b/org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheTreeTest.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2008, Google Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.dircache;
+
+import org.spearce.jgit.lib.RepositoryTestCase;
+
+public class DirCacheTreeTest extends RepositoryTestCase {
+ public void testEmptyCache_NoCacheTree() throws Exception {
+ final DirCache dc = DirCache.read(db);
+ assertNull(dc.getCacheTree(false));
+ }
+
+ public void testEmptyCache_CreateEmptyCacheTree() throws Exception {
+ final DirCache dc = DirCache.read(db);
+ final DirCacheTree tree = dc.getCacheTree(true);
+ assertNotNull(tree);
+ assertSame(tree, dc.getCacheTree(false));
+ assertSame(tree, dc.getCacheTree(true));
+ assertEquals("", tree.getNameString());
+ assertEquals("", tree.getPathString());
+ assertEquals(0, tree.getChildCount());
+ assertEquals(0, tree.getEntrySpan());
+ assertFalse(tree.isValid());
+ }
+
+ public void testEmptyCache_Clear_NoCacheTree() throws Exception {
+ final DirCache dc = DirCache.read(db);
+ final DirCacheTree tree = dc.getCacheTree(true);
+ assertNotNull(tree);
+ dc.clear();
+ assertNull(dc.getCacheTree(false));
+ assertNotSame(tree, dc.getCacheTree(true));
+ }
+
+ public void testSingleSubtree() throws Exception {
+ final DirCache dc = DirCache.read(db);
+
+ final String[] paths = { "a.", "a/b", "a/c", "a/d", "a0b" };
+ final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
+ for (int i = 0; i < paths.length; i++)
+ ents[i] = new DirCacheEntry(paths[i]);
+ final int aFirst = 1;
+ final int aLast = 3;
+
+ final DirCacheBuilder b = dc.builder();
+ for (int i = 0; i < ents.length; i++)
+ b.add(ents[i]);
+ b.finish();
+
+ assertNull(dc.getCacheTree(false));
+ final DirCacheTree root = dc.getCacheTree(true);
+ assertNotNull(root);
+ assertSame(root, dc.getCacheTree(true));
+ assertEquals("", root.getNameString());
+ assertEquals("", root.getPathString());
+ assertEquals(1, root.getChildCount());
+ assertEquals(dc.getEntryCount(), root.getEntrySpan());
+ assertFalse(root.isValid());
+
+ final DirCacheTree aTree = root.getChild(0);
+ assertNotNull(aTree);
+ assertSame(aTree, root.getChild(0));
+ assertEquals("a", aTree.getNameString());
+ assertEquals("a/", aTree.getPathString());
+ assertEquals(0, aTree.getChildCount());
+ assertEquals(aLast - aFirst + 1, aTree.getEntrySpan());
+ assertFalse(aTree.isValid());
+ }
+
+ public void testTwoLevelSubtree() throws Exception {
+ final DirCache dc = DirCache.read(db);
+
+ final String[] paths = { "a.", "a/b", "a/c/e", "a/c/f", "a/d", "a0b" };
+ final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
+ for (int i = 0; i < paths.length; i++)
+ ents[i] = new DirCacheEntry(paths[i]);
+ final int aFirst = 1;
+ final int aLast = 4;
+ final int acFirst = 2;
+ final int acLast = 3;
+
+ final DirCacheBuilder b = dc.builder();
+ for (int i = 0; i < ents.length; i++)
+ b.add(ents[i]);
+ b.finish();
+
+ assertNull(dc.getCacheTree(false));
+ final DirCacheTree root = dc.getCacheTree(true);
+ assertNotNull(root);
+ assertSame(root, dc.getCacheTree(true));
+ assertEquals("", root.getNameString());
+ assertEquals("", root.getPathString());
+ assertEquals(1, root.getChildCount());
+ assertEquals(dc.getEntryCount(), root.getEntrySpan());
+ assertFalse(root.isValid());
+
+ final DirCacheTree aTree = root.getChild(0);
+ assertNotNull(aTree);
+ assertSame(aTree, root.getChild(0));
+ assertEquals("a", aTree.getNameString());
+ assertEquals("a/", aTree.getPathString());
+ assertEquals(1, aTree.getChildCount());
+ assertEquals(aLast - aFirst + 1, aTree.getEntrySpan());
+ assertFalse(aTree.isValid());
+
+ final DirCacheTree acTree = aTree.getChild(0);
+ assertNotNull(acTree);
+ assertSame(acTree, aTree.getChild(0));
+ assertEquals("c", acTree.getNameString());
+ assertEquals("a/c/", acTree.getPathString());
+ assertEquals(0, acTree.getChildCount());
+ assertEquals(acLast - acFirst + 1, acTree.getEntrySpan());
+ assertFalse(acTree.isValid());
+ }
+}
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Reply | Threaded
Open this post in threaded view
|

[EGIT PATCH 20/26] Allow the new DirCacheIterator in command line arguments

Shawn Pearce
In reply to this post by Shawn Pearce
By assuming files passed where we want an AbtractTreeIterator to
be supplied are actually 'DIRC' files (aka .git/index) we can
automatically load them for the command line tool.

Signed-off-by: Shawn O. Pearce <[hidden email]>
---
 .../jgit/pgm/opt/AbstractTreeIteratorHandler.java  |   13 +++++++++++++
 1 files changed, 13 insertions(+), 0 deletions(-)

diff --git a/org.spearce.jgit.pgm/src/org/spearce/jgit/pgm/opt/AbstractTreeIteratorHandler.java b/org.spearce.jgit.pgm/src/org/spearce/jgit/pgm/opt/AbstractTreeIteratorHandler.java
index 8e216c7..e439c87 100644
--- a/org.spearce.jgit.pgm/src/org/spearce/jgit/pgm/opt/AbstractTreeIteratorHandler.java
+++ b/org.spearce.jgit.pgm/src/org/spearce/jgit/pgm/opt/AbstractTreeIteratorHandler.java
@@ -46,6 +46,8 @@ import org.kohsuke.args4j.OptionDef;
 import org.kohsuke.args4j.spi.OptionHandler;
 import org.kohsuke.args4j.spi.Parameters;
 import org.kohsuke.args4j.spi.Setter;
+import org.spearce.jgit.dircache.DirCache;
+import org.spearce.jgit.dircache.DirCacheIterator;
 import org.spearce.jgit.errors.IncorrectObjectTypeException;
 import org.spearce.jgit.errors.MissingObjectException;
 import org.spearce.jgit.lib.ObjectId;
@@ -87,6 +89,17 @@ public class AbstractTreeIteratorHandler extends
  return 1;
  }
 
+ if (new File(name).isFile()) {
+ final DirCache dirc;
+ try {
+ dirc = DirCache.read(new File(name));
+ } catch (IOException e) {
+ throw new CmdLineException(name + " is not an index file", e);
+ }
+ setter.addValue(new DirCacheIterator(dirc));
+ return 1;
+ }
+
  final ObjectId id;
  try {
  id = clp.getRepository().resolve(name);
--
1.6.0.rc2.22.g71b99

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [hidden email]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
12