Java DirCacheEntry类代码示例

import org.eclipse.jgit.dircache.DirCacheEntry; //导入依赖的package包/类
public void checkoutEntry (Repository repository, File file, DirCacheEntry e, ObjectReader od) throws IOException, GitException {
    // ... create/overwrite this file ...
    if (!ensureParentFolderExists(file.getParentFile())) {
        return;
    }

    boolean exists = file.exists();
    if (exists && e.getFileMode() == FileMode.SYMLINK) {
        monitor.notifyWarning(MessageFormat.format(Utils.getBundle(CheckoutIndex.class).getString("MSG_Warning_SymLink"), file.getAbsolutePath())); //NOI18N
        return;
    }

    if (Utils.isFromNested(e.getFileMode().getBits())) {
        if (!exists) {
            file.mkdirs();
        }
    } else {
        if (exists && file.isDirectory()) {
            monitor.notifyWarning(MessageFormat.format(Utils.getBundle(CheckoutIndex.class).getString("MSG_Warning_ReplacingDirectory"), file.getAbsolutePath())); //NOI18N
            Utils.deleteRecursively(file);
        }
        file.createNewFile();
        if (file.isFile()) {
            DirCacheCheckout.checkoutEntry(repository, file, e, od);
        } else {
            monitor.notifyError(MessageFormat.format(Utils.getBundle(CheckoutIndex.class).getString("MSG_Warning_CannotCreateFile"), file.getAbsolutePath())); //NOI18N
        }
    }
}
 

import org.eclipse.jgit.dircache.DirCacheEntry; //导入依赖的package包/类
public void testAddMissingSymlink () throws Exception {
    if (isWindows()) {
        return;
    }
    String path = "folder/file";
    File f = new File(workDir, path);
    
    // try with commandline client
    File link = new File(workDir, "link");
    Files.createSymbolicLink(Paths.get(link.getAbsolutePath()), Paths.get(path));
    getClient(workDir).add(new File[] { link }, NULL_PROGRESS_MONITOR);
    DirCacheEntry e = repository.readDirCache().getEntry(link.getName());
    assertEquals(FileMode.SYMLINK, e.getFileMode());
    assertEquals(0, e.getLength());
    ObjectReader reader = repository.getObjectDatabase().newReader();
    assertTrue(reader.has(e.getObjectId()));
    byte[] bytes = reader.open(e.getObjectId()).getBytes();
    assertEquals(path, RawParseUtils.decode(bytes));
    reader.release();
}
 

import org.eclipse.jgit.dircache.DirCacheEntry; //导入依赖的package包/类
private void assertDirCacheEntryModified (Collection<File> files) throws IOException {
    DirCache cache = repository.lockDirCache();
    for (File f : files) {
        String relativePath = Utils.getRelativePath(workDir, f);
        DirCacheEntry e = cache.getEntry(relativePath);
        assertNotNull(e);
        assertEquals(relativePath, e.getPathString());
        InputStream in = new FileInputStream(f);
        try {
            assertNotSame(e.getObjectId(), repository.newObjectInserter().idFor(Constants.OBJ_BLOB, f.length(), in));
        } finally {
            in.close();
        }
    }
    cache.unlock();
}
 

import org.eclipse.jgit.dircache.DirCacheEntry; //导入依赖的package包/类
protected static void assertDirCacheEntry (Repository repository, File workDir, Collection<File> files) throws IOException {
    DirCache cache = repository.lockDirCache();
    for (File f : files) {
        String relativePath = Utils.getRelativePath(workDir, f);
        DirCacheEntry e = cache.getEntry(relativePath);
        assertNotNull(e);
        assertEquals(relativePath, e.getPathString());
        if (f.lastModified() != e.getLastModified()) {
            assertEquals((f.lastModified() / 1000) * 1000, (e.getLastModified() / 1000) * 1000);
        }
        try (InputStream in = new FileInputStream(f)) {
            assertEquals(e.getObjectId(), repository.newObjectInserter().idFor(Constants.OBJ_BLOB, f.length(), in));
        }
        if (e.getLength() == 0 && f.length() != 0) {
            assertTrue(e.isSmudged());
        } else {
            assertEquals(f.length(), e.getLength());
        }
    }
    cache.unlock();
}
 

import org.eclipse.jgit.dircache.DirCacheEntry; //导入依赖的package包/类
private DirCacheEntry[] findEntrys(Repository repository, String path) throws IOException {
    DirCache dirCache = repository.readDirCache();

    int eIdx = dirCache.findEntry(path);
    if (eIdx < 0) {
        throw new GitInvalidPathException(format("%s is not found in git index", path));
    }

    int lastIdx = dirCache.nextEntry(eIdx);

    final DirCacheEntry[] entries = new DirCacheEntry[lastIdx - eIdx];
    for (int i=0; i<entries.length; i++) {
        entries[i] = dirCache.getEntry(eIdx + i);
    }

    return entries;
}
 

import org.eclipse.jgit.dircache.DirCacheEntry; //导入依赖的package包/类
private void buildDirCache(TreeWalk walk, DirCacheBuilder builder)
		throws MissingObjectException, IncorrectObjectTypeException,
		CorruptObjectException, IOException {
	while (walk.next()) {
		AbstractTreeIterator cIter = walk.getTree(0,
				AbstractTreeIterator.class);
		if (cIter == null) {
			// Not in commit, don't add to new index
			continue;
		}

		final DirCacheEntry entry = new DirCacheEntry(walk.getRawPath());
		entry.setFileMode(cIter.getEntryFileMode());
		entry.setObjectIdFromRaw(cIter.idBuffer(), cIter.idOffset());

		DirCacheIterator dcIter = walk.getTree(1, DirCacheIterator.class);
		if (dcIter != null && dcIter.idEqual(cIter)) {
			DirCacheEntry indexEntry = dcIter.getDirCacheEntry();
			entry.setLastModified(indexEntry.getLastModified());
			entry.setLength(indexEntry.getLength());
		}

		builder.add(entry);
	}
}
 

import org.eclipse.jgit.dircache.DirCacheEntry; //导入依赖的package包/类
public boolean findNext() {
  while(index < entries.length) {
    DirCacheEntry entry = entries[index++];
    String nextPath = "/" + entry.getPathString();
    if(directParentLength == -1)
      next = CacheNode.file(nextPath, entry);
    else {
      if(prev != null && prev.hasChild(nextPath))
        continue;
      int end = nextPath.indexOf('/', directParentLength);
      next = end != -1 ? CacheNode.directory(nextPath.substring(0, end)) : CacheNode.file(nextPath, entry);
    }
    return true;
  }
  return false;
}
 

import org.eclipse.jgit.dircache.DirCacheEntry; //导入依赖的package包/类
protected void saveFile(String fileName, byte[] raw) throws IOException {
  DirCacheEditor editor = newTree.editor();
  if (raw != null && 0 < raw.length) {
    final ObjectId blobId = inserter.insert(Constants.OBJ_BLOB, raw);
    editor.add(
        new PathEdit(fileName) {
          @Override
          public void apply(DirCacheEntry ent) {
            ent.setFileMode(FileMode.REGULAR_FILE);
            ent.setObjectId(blobId);
          }
        });
  } else {
    editor.add(new DeletePath(fileName));
  }
  editor.finish();
}
 

import org.eclipse.jgit.dircache.DirCacheEntry; //导入依赖的package包/类
public Optional<ObjectId> execute() {
    final Map<String, String> content = commitContent.getContent();
    final DirCacheEditor editor = DirCache.newInCore().editor();
    final List<String> pathsAdded = new ArrayList<>();

    try {
        iterateOverTreeWalk(git,
                            headId,
                            (walkPath, hTree) -> {
                                final String toPath = content.get(walkPath);
                                final DirCacheEntry dcEntry = new DirCacheEntry((toPath == null) ? walkPath : toPath);
                                if (!pathsAdded.contains(dcEntry.getPathString())) {
                                    addToTemporaryInCoreIndex(editor,
                                                              dcEntry,
                                                              hTree.getEntryObjectId(),
                                                              hTree.getEntryFileMode());
                                    pathsAdded.add(dcEntry.getPathString());
                                }
                            });
        editor.finish();
    } catch (final Exception e) {
        throw new RuntimeException(e);
    }

    return buildTree(editor);
}
 

import org.eclipse.jgit.dircache.DirCacheEntry; //导入依赖的package包/类
public Optional<ObjectId> execute() {
    final DirCacheEditor editor = DirCache.newInCore().editor();

    try {
        iterateOverTreeWalk(git,
                            headId,
                            (walkPath, hTree) -> {
                                addToTemporaryInCoreIndex(editor,
                                                          new DirCacheEntry(walkPath),
                                                          hTree.getEntryObjectId(),
                                                          hTree.getEntryFileMode());
                            });

        editor.finish();
    } catch (final Exception e) {
        throw new RuntimeException(e);
    }

    return buildTree(editor);
}
 

import org.eclipse.jgit.dircache.DirCacheEntry; //导入依赖的package包/类
public static void main(String[] args) throws IOException {
    try (Repository repository = CookbookHelper.openJGitCookbookRepository()) {
        // DirCache contains all files of the repository
        DirCache index = DirCache.read(repository);
        System.out.println("DirCache has " + index.getEntryCount() + " items");
        for (int i = 0; i < index.getEntryCount(); i++) {
            // the number after the AnyObjectId is the "stage", see the constants in DirCacheEntry
            System.out.println("Item " + i + ": " + index.getEntry(i));
        }

        //
        System.out.println("Now printing staged items...");
        for (int i = 0; i < index.getEntryCount(); i++) {
            DirCacheEntry entry = index.getEntry(i);
            if (entry.getStage() != DirCacheEntry.STAGE_0) {
                System.out.println("Item " + i + ": " + entry);
            }
        }
    }
}
 

import org.eclipse.jgit.dircache.DirCacheEntry; //导入依赖的package包/类
@Override
public String call() throws GitAPIException {
	try {
		DirCache index = repo.lockDirCache();
		DirCacheEntry entry = index.getEntry(fileName);

		if (entry != null) {
			entry.setAssumeValid(assumeUnchanged);
			index.write();
			index.commit();
			return entry.getPathString();
		}
	} catch (IOException e) {
		throw new JGitInternalException(e.getMessage(), e);
	}

	return null;
}
 

import org.eclipse.jgit.dircache.DirCacheEntry; //导入依赖的package包/类
private DirCache createTreeDirCache(Map<SubtreeConfig, RevCommit> parentCommits,
		String commitMessage) throws IOException {

	try (TreeWalk treeWalk = new TreeWalk(repository)) {
		treeWalk.setRecursive(true);
		addTrees(parentCommits, treeWalk);

		DirCacheBuilder builder = DirCache.newInCore().builder();
		while (treeWalk.next()) {
			AbstractTreeIterator iterator = getSingleTreeIterator(treeWalk, commitMessage);
			if (iterator == null) {
				throw new IllegalStateException(
						"Tree walker did not return a single tree (should not happen): "
								+ treeWalk.getPathString());
			}
			byte[] path = Arrays.copyOf(iterator.getEntryPathBuffer(),
					iterator.getEntryPathLength());
			DirCacheEntry entry = new DirCacheEntry(path);
			entry.setFileMode(iterator.getEntryFileMode());
			entry.setObjectId(iterator.getEntryObjectId());
			builder.add(entry);
		}
		builder.finish();
		return builder.getDirCache();
	}
}
 

import org.eclipse.jgit.dircache.DirCacheEntry; //导入依赖的package包/类
private void assertNullDirCacheEntry (Collection<File> files) throws Exception {
    DirCache cache = repository.lockDirCache();
    for (File f : files) {
        DirCacheEntry e = cache.getEntry(Utils.getRelativePath(workDir, f));
        assertNull(e);
    }
    cache.unlock();
}
 

import org.eclipse.jgit.dircache.DirCacheEntry; //导入依赖的package包/类
public void testLargeFile () throws Exception {
    unpack("large.dat.zip");
    File large = new File(workDir, "large.dat");
    assertTrue(large.exists());
    assertEquals(2158310, large.length());
    add();
    DirCache cache = repository.readDirCache();
    DirCacheEntry e = cache.getEntry("large.dat");
    WindowCacheConfig cfg = new WindowCacheConfig();
    cfg.setStreamFileThreshold((int) large.length() - 1);
    cfg.install();
    DirCacheCheckout.checkoutEntry(repository, large, e);
}