Java AnyObjectId类代码示例

import org.eclipse.jgit.lib.AnyObjectId; //导入依赖的package包/类
/**
 * Locate a reference to any object without loading it.
 * <p>
 * The object may or may not exist in the repository. It is impossible to
 * tell from this method's return value.
 *
 * @param id
 *            name of the object.
 * @param type
 *            type of the object. Must be a valid Git object type.
 * @return reference to the object. Never null.
 */
public RevObject lookupAny(final AnyObjectId id, final int type) {
	RevObject r = objects.get(id);
	if (r == null) {
		switch (type) {
		case Constants.OBJ_COMMIT:
			r = createCommit(id);
			break;
		case Constants.OBJ_TREE:
			r = new RevTree(id);
			break;
		case Constants.OBJ_BLOB:
			r = new RevBlob(id);
			break;
		case Constants.OBJ_TAG:
			r = new RevTag(id);
			break;
		default:
			throw new IllegalArgumentException(MessageFormat.format(
					JGitText.get().invalidGitType, Integer.valueOf(type)));
		}
		objects.add(r);
	}
	return r;
}
 

import org.eclipse.jgit.lib.AnyObjectId; //导入依赖的package包/类
/**
 * 
 * @param columns
 * @param objectInserter
 * @param tblTree
 * @param walkTbl
 * @return
 * @throws SQLException
 * @throws IOException 
 */
public static ObjectId putColumnMetaAsObject(ResultSet columns, 
        ObjectInserter objectInserter, TreeFormatter tblTree, RevWalk walkTbl) throws SQLException, IOException {

    // Build object for column attributs
    ObjectId objectId = buildMetaObject(columns, Consts.COLUMN_META_ATTRIBUTES, objectInserter);

    tblTree.append(Consts.COLUMN_META, FileMode.REGULAR_FILE, (AnyObjectId) objectId);

    // Add empty tree for the column content
    TreeFormatter clmnDataTree = new TreeFormatter();
    ObjectId clmnDataTreeId = objectInserter.insert(clmnDataTree);
    objectInserter.flush();

    tblTree.append(Consts.COLUMN_DATA, walkTbl.parseTree(clmnDataTreeId));

    return objectId;
}
 

import org.eclipse.jgit.lib.AnyObjectId; //导入依赖的package包/类
@Nonnull
private Result updateFileSystemStatus(GfsStatusProvider.Update update, Merger merger) throws IOException {
  AnyObjectId treeId = merger.getResultTreeId();
  checkout(gfs, treeId);
  RevCommit newCommit = null;
  if(commit && !squash) {
    prepareCommitter();
    newCommit = createCommit(message, treeId, committer, committer, Arrays.asList(headCommit, sourceHeadCommit), repo);
    BranchUtils.merge(branch, newCommit, sourceRef, "Merge made by " + strategy.getName() + ".", repo);
    update.commit(newCommit);
  }
  if(!commit) {
    update.mergeNote(MergeNote.mergeNoCommit(sourceHeadCommit, message));
    return Result.mergedNotCommitted();
  }
  if(squash) {
    update.mergeNote(MergeNote.mergeSquash(message));
    return Result.mergedSquashed();
  }
  return Result.merged(newCommit);
}
 

import org.eclipse.jgit.lib.AnyObjectId; //导入依赖的package包/类
@Nonnull
@Override
protected GfsCreateStash.Result doExecute(GfsStatusProvider.Update update) throws IOException {
  prepareBranch();
  prepareCommitter();
  prepareParent();
  prepareIndexMessage();
  prepareDirectoryMessage();
  AnyObjectId resultTree = gfs.flush();
  GfsCreateStash.Result result;
  if(parent != null && parent.getTree().equals(resultTree)) {
    result = noChange();
  } else {
    RevCommit indexCommit = makeIndexCommit(resultTree);
    RevCommit stashCommit = makeWorkingDirectoryCommit(indexCommit);
    addToStash(stashCommit, repo);
    result = success(stashCommit);
  }
  return result;
}
 

import org.eclipse.jgit.lib.AnyObjectId; //导入依赖的package包/类
public static GitRepoMetaData getGitRepositoryMetaData(String repoPath) {
        try {
            if(!repoPath.endsWith(".git"))
                repoPath = repoPath+File.separator+".git";
            System.out.println("repopath:  "+repoPath);
            GitRepoMetaData gitMetaData = new GitRepoMetaData();
            FileRepositoryBuilder builder = new FileRepositoryBuilder();
            Repository repository = builder.setGitDir(new File(repoPath))
                    .readEnvironment()
                    .setMustExist(true)
                    .findGitDir()
                    .build();
            RevWalk walk = new RevWalk(repository);
            AnyObjectId id = repository.resolve("HEAD");
            if(id == null)
                return null;//Empty repository
            RevCommit rCommit =walk.parseCommit(id);
            walk.markStart(rCommit);
            gitMetaData.setRepository(repository);
            gitMetaData.setRevWalk(walk);
            return gitMetaData;
        } catch (IOException exception) {
//[LOG]            logger.debug("IOException getGitRepositoryMetaData", exception);
        };
        return null;
    }
 

import org.eclipse.jgit.lib.AnyObjectId; //导入依赖的package包/类
public RevCommit getSrcCommit() {
    try {
        RevWalk revWalk = new RevWalk(git.getRepository());
        AnyObjectId headId = git.getRepository().resolve(Constants.HEAD);
        RevCommit root = revWalk.parseCommit(headId);
        revWalk.sort(RevSort.REVERSE);
        revWalk.markStart(root);
        return revWalk.next();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

import org.eclipse.jgit.lib.AnyObjectId; //导入依赖的package包/类
public List<Path> getChangedFiles() throws IOException {
    List<Path> changedFiles = new ArrayList<>();
    RevWalk revWalk = new RevWalk(git.getRepository());
    AnyObjectId headId = git.getRepository().resolve(Constants.HEAD);
    RevCommit head = revWalk.parseCommit(headId);
    DiffFormatter formatter = new DiffFormatter(null);
    formatter.setRepository(git.getRepository());
    formatter.setDiffComparator(RawTextComparator.DEFAULT);
    formatter.setDetectRenames(true);
    List<DiffEntry> entries = formatter.scan(getSrcCommit().getTree(), head);
    entries.forEach((diffEntry -> changedFiles.add(Paths.get(diffEntry.getPath(DiffEntry.Side.NEW)))));
    return changedFiles;
}
 

import org.eclipse.jgit.lib.AnyObjectId; //导入依赖的package包/类
private String getCommitIndexVersion(final IndexSearcher searcher, AnyObjectId commitId) throws IOException {
	final AtomicReference<String> indexVersion = new AtomicReference<>(null);
	
	searcher.search(COMMIT_HASH.query(commitId.getName()), new Collector() {

		private int docBase;
		
		@Override
		public void setScorer(Scorer scorer) throws IOException {
		}

		@Override
		public void collect(int doc) throws IOException {
			indexVersion.set(searcher.doc(docBase+doc).get(COMMIT_INDEX_VERSION.name()));
		}

		@Override
		public void setNextReader(AtomicReaderContext context) throws IOException {
			docBase = context.docBase;
		}

		@Override
		public boolean acceptsDocsOutOfOrder() {
			return true;
		}
		
	});
	return indexVersion.get();
}
 

import org.eclipse.jgit.lib.AnyObjectId; //导入依赖的package包/类
private RevObject parseNew(AnyObjectId id, ObjectLoader ldr)
		throws LargeObjectException, CorruptObjectException,
		MissingObjectException, IOException {
	RevObject r;
	int type = ldr.getType();
	switch (type) {
	case Constants.OBJ_COMMIT: {
		final RevCommit c = createCommit(id);
		c.parseCanonical(this, getCachedBytes(c, ldr));
		r = c;
		break;
	}
	case Constants.OBJ_TREE: {
		r = new RevTree(id);
		r.flags |= PARSED;
		break;
	}
	case Constants.OBJ_BLOB: {
		r = new RevBlob(id);
		r.flags |= PARSED;
		break;
	}
	case Constants.OBJ_TAG: {
		final RevTag t = new RevTag(id);
		t.parseCanonical(this, getCachedBytes(t, ldr));
		r = t;
		break;
	}
	default:
		throw new IllegalArgumentException(MessageFormat.format(
				JGitText.get().badObjectType, Integer.valueOf(type)));
	}
	objects.add(r);
	return r;
}
 

import org.eclipse.jgit.lib.AnyObjectId; //导入依赖的package包/类
public static List<DiffEntry> diff(Repository repository, AnyObjectId oldRevId, AnyObjectId newRevId) {
	List<DiffEntry> diffs = new ArrayList<>();
	try (	DiffFormatter diffFormatter = new DiffFormatter(NullOutputStream.INSTANCE);
			RevWalk revWalk = new RevWalk(repository);
			ObjectReader reader = repository.newObjectReader();) {
    	diffFormatter.setRepository(repository);
    	diffFormatter.setDetectRenames(true);
    	diffFormatter.setDiffComparator(RawTextComparator.DEFAULT);
    	
    	CanonicalTreeParser oldTreeParser = new CanonicalTreeParser();
    	if (!oldRevId.equals(ObjectId.zeroId()))
    		oldTreeParser.reset(reader, revWalk.parseCommit(oldRevId).getTree());
    	
    	CanonicalTreeParser newTreeParser = new CanonicalTreeParser();
    	if (!newRevId.equals(ObjectId.zeroId()))
    		newTreeParser.reset(reader, revWalk.parseCommit(newRevId).getTree());
    	
    	for (DiffEntry entry: diffFormatter.scan(oldTreeParser, newTreeParser)) {
    		if (!Objects.equal(entry.getOldPath(), entry.getNewPath())
    				|| !Objects.equal(entry.getOldMode(), entry.getNewMode())
    				|| entry.getOldId()==null || !entry.getOldId().isComplete()
    				|| entry.getNewId()== null || !entry.getNewId().isComplete()
    				|| !entry.getOldId().equals(entry.getNewId())) {
    			diffs.add(entry);
    		}
    	}
	} catch (IOException e) {
		throw new RuntimeException(e);
	}			
	return diffs;
}
 

import org.eclipse.jgit.lib.AnyObjectId; //导入依赖的package包/类
/**
 * Restore to the initial state of the repository. Only applicable if the
 * repository has conflicts
 */
public void restartMerge() {
	try {
		AnyObjectId commitToMerge = git.getRepository().resolve("MERGE_HEAD");
		git.clean().call();
		git.reset().setMode(ResetType.HARD).call();
		git.merge().include(commitToMerge).setStrategy(MergeStrategy.RECURSIVE).call();
		
		fireFileStateChanged(new ChangeEvent(GitCommand.MERGE_RESTART, Collections.<String> emptyList()));
	} catch (GitAPIException | IOException e) {
		if (logger.isDebugEnabled()) {
			logger.debug(END_FETCH_DEBUG_MESSAGE);
		}
	}
}
 

import org.eclipse.jgit.lib.AnyObjectId; //导入依赖的package包/类
private static void setupMergeCommand(MergeCommand merge, List<Ref> commitsByRef, List<AnyObjectId> commitsById,
                                      List<NamedCommit> commitsByNameAndId, ProgressMonitor monitor,
                                      MergeStrategy strategy, MergeCommand.FastForwardMode fastForwardMode) {
    commitsByRef.forEach(merge::include);
    commitsById.forEach(merge::include);
    commitsByNameAndId.forEach(nc -> merge.include(nc.getName(), nc.getObjectId()));

    if (monitor != null) { merge.setProgressMonitor(monitor); }

    merge
            .setFastForward(fastForwardMode)
            .setStrategy(strategy);
}
 

import org.eclipse.jgit.lib.AnyObjectId; //导入依赖的package包/类
public static MergeResult mergeWithSquash(Git git, MergeStrategy strategy,  List<Ref> commitsByRef,
                                   List<AnyObjectId> commitsById, List<NamedCommit> commitsByNameAndId,
                                   MergeCommand.FastForwardMode fastForwardMode,
                                   ProgressMonitor monitor) throws GitAPIException {
    MergeCommand merge = git.merge();

    setupMergeCommand(merge, commitsByRef, commitsById, commitsByNameAndId, monitor, strategy, fastForwardMode);

    return merge
            .setStrategy(strategy)
            .setFastForward(fastForwardMode)
            .setSquash(true)
            .call();
}
 

import org.eclipse.jgit.lib.AnyObjectId; //导入依赖的package包/类
public static MergeResult mergeWithoutCommit(Git git, MergeStrategy strategy, List<Ref> commitsByRef,
                                      List<AnyObjectId> commitsById, List<NamedCommit> commitsByNameAndId,
                                      MergeCommand.FastForwardMode fastForwardMode,
                                      ProgressMonitor monitor) throws GitAPIException {
    MergeCommand merge = git.merge();

    setupMergeCommand(merge, commitsByRef, commitsById, commitsByNameAndId, monitor, strategy, fastForwardMode);

    return merge
            .setStrategy(strategy)
            .setFastForward(fastForwardMode)
            .setCommit(false)
            .call();
}
 

import org.eclipse.jgit.lib.AnyObjectId; //导入依赖的package包/类
public static MergeResult mergeWithCommit(Git git, MergeStrategy strategy, List<Ref> commitsByRef, List<AnyObjectId> commitsById,
                                          List<NamedCommit> commitsByNameAndId, String commitMessage,
                                          MergeCommand.FastForwardMode fastForwardMode,
                                          ProgressMonitor monitor) throws GitAPIException {
    MergeCommand merge = git.merge();

    setupMergeCommand(merge, commitsByRef, commitsById, commitsByNameAndId, monitor, strategy, fastForwardMode);

    return git.merge()
            .setMessage(commitMessage)           // message to be used for merge commit
            .call();
}