Java ResetType类代码示例

import org.eclipse.jgit.api.ResetCommand.ResetType; //导入依赖的package包/类
public void reset(final int noOfCommitsToRevert, final String message) {
    final Repository repository = getRepository();
    final RevCommit commit = findCommit(Constants.HEAD
            + REVISION_STRING_DELIMITER + noOfCommitsToRevert, repository);
    if (commit == null) {
        return;
    }

    try {
        final Git git = new Git(repository);
        git.reset().setRef(commit.getName()).setMode(ResetType.HARD).call();
        // Commit changes
        commitAllChanges(message);
        LOGGER.info("Reset of last " + (noOfCommitsToRevert + 1)
                + " successful.");
    }
    catch (final Exception e) {
        throw new IllegalStateException("Reset did not succeed.", e);
    }
}
 

import org.eclipse.jgit.api.ResetCommand.ResetType; //导入依赖的package包/类
private void cherryPickCommitToBranch(ObjectId id, Project project, Branch branch) {

		doWithGit(project, git -> {

			try {
				checkout(project, branch);
			} catch (RuntimeException o_O) {

				logger.log(project, "Couldn't check out branch %s. Skipping cherrypick of commit %s.", branch, id.getName());
				return;
			}

			logger.log(project, "git cp %s", id.getName());
			CherryPickResult result = git.cherryPick().include(id).call();

			if (result.getStatus().equals(CherryPickStatus.OK)) {
				logger.log(project, "Successfully cherry-picked commit %s to branch %s.", id.getName(), branch);
			} else {
				logger.warn(project, "Cherry pick failed. aborting…");
				logger.log(project, "git reset --hard");
				git.reset().setMode(ResetType.HARD).call();
			}
		});
	}
 

import org.eclipse.jgit.api.ResetCommand.ResetType; //导入依赖的package包/类
@Override
protected void buttonPressed(int buttonId) {
	switch (buttonId) {
	case IDialogConstants.PROCEED_ID:
		CommitUI commitUI = new CommitUI(getShell(), repository,
				new IResource[0], true);
		shouldContinue = commitUI.commit();
		break;
	case IDialogConstants.ABORT_ID:
		final ResetOperation operation = new ResetOperation(repository,
				Constants.HEAD, ResetType.HARD);
		String jobname = NLS.bind(UIText.ResetAction_reset, Constants.HEAD);
		JobUtil.scheduleUserWorkspaceJob(operation, jobname,
				JobFamilies.RESET);
		shouldContinue = true;
		break;
	case IDialogConstants.SKIP_ID:
		StashCreateUI stashCreateUI = new StashCreateUI(repository);
		shouldContinue = stashCreateUI.createStash(getShell());
		break;
	case IDialogConstants.CANCEL_ID:
	}
	super.buttonPressed(buttonId);
}
 

import org.eclipse.jgit.api.ResetCommand.ResetType; //导入依赖的package包/类
public void execute(IProgressMonitor m) throws CoreException {
	IProgressMonitor monitor;
	if (m == null)
		monitor = new NullProgressMonitor();
	else
		monitor = m;
	if (type == ResetType.HARD) {
		IWorkspaceRunnable action = new IWorkspaceRunnable() {
			public void run(IProgressMonitor actMonitor) throws CoreException {
				reset(actMonitor);
			}
		};
		// lock workspace to protect working tree changes
		ResourcesPlugin.getWorkspace().run(action, getSchedulingRule(),
				IWorkspace.AVOID_UPDATE, monitor);
	} else {
		reset(monitor);
	}
}
 

import org.eclipse.jgit.api.ResetCommand.ResetType; //导入依赖的package包/类
public static void pullRepository() {
	try {
 	logger.info("Scanning devices folder for changes.");
 	git.add().addFilepattern(".").call();
 	Status status = git.status().call();
 	if (status.getChanged().size()>0 || status.getAdded().size()>0 || status.getModified().size()>0) {
 		logger.info("Changes have been found. Doing a hard reset (removing user modifications).");
 		ResetCommand reset = git.reset();
 		reset.setMode(ResetType.HARD);
 		reset.setRef(Constants.HEAD);
 		reset.call();
 	}
 	logger.info("Pulling changes from github.");
 	git.pull().call();
	} catch (NoHeadException e) {
		logger.info("Pull failed. Trying to clone repository instead");
		closeRepository();
		cloneRepository();
	}
	catch (Exception e1) {
		closeRepository();
	}
}
 

import org.eclipse.jgit.api.ResetCommand.ResetType; //导入依赖的package包/类
private Ref resetHard(Git git, String label, String ref) {
	ResetCommand reset = git.reset();
	reset.setRef(ref);
	reset.setMode(ResetType.HARD);
	try {
		Ref resetRef = reset.call();
		if (resetRef != null) {
			this.logger.info(
					"Reset label " + label + " to version " + resetRef.getObjectId());
		}
		return resetRef;
	}
	catch (Exception ex) {
		String message = "Could not reset to remote for " + label + " (current ref="
				+ ref + "), remote: " + git.getRepository().getConfig()
						.getString("remote", "origin", "url");
		warn(message, ex);
		return null;
	}
}
 

import org.eclipse.jgit.api.ResetCommand.ResetType; //导入依赖的package包/类
/**
 * Switch to the main branch and delete the temporary branch.
 *
 * @throws GitAPIException
 * @throws RefAlreadyExistsException
 * @throws RefNotFoundException
 * @throws InvalidRefNameException
 * @throws CheckoutConflictException
 * @throws NotMergedException
 * @throws CannotDeleteCurrentBranchException
 */
private void switchToMainAndDeleteFrom(final String tempBranch)
		throws GitAPIException, RefAlreadyExistsException,
		RefNotFoundException, InvalidRefNameException,
		CheckoutConflictException, NotMergedException,
		CannotDeleteCurrentBranchException {
	try {
		repository.reset().setMode(ResetType.HARD).call();
	} finally {
		try {
			repository.checkout().setCreateBranch(false)
			.setName(mainBranchName).setForce(true).call();
		} finally {
			try {
				repository.reset().setMode(ResetType.HARD).call();
			} finally {
				repository.branchDelete().setForce(true)
				.setBranchNames(tempBranch).call();
			}
		}
	}
}
 

import org.eclipse.jgit.api.ResetCommand.ResetType; //导入依赖的package包/类
@Override
public void checkout(String hash) {
	LOG.info(String.format("Checking out %s.", hash));
	File lockFile = new File(git.getRepository().getDirectory(), "git/index.lock");
	if (lockFile.exists()) {
		lockFile.delete();
	}

	try {
		git.reset().setMode(ResetType.HARD).call();
		git.checkout().setName("master").call();
		
		git.checkout().setCreateBranch(true).setName("rm_branch"+branchCounter++)
		.setStartPoint(hash).setForce(true).setOrphan(true).call();
	} catch (GitAPIException e) {
		close();
		throw new RepositoryMinerException(e);
	}
}
 

import org.eclipse.jgit.api.ResetCommand.ResetType; //导入依赖的package包/类
/**
 * If mode is set, apply the specified mode according to Git manual.
 *
 * @antdoc.notrequired
 * @param mode the mode used to perform git reset. (Default is MIXED)
 */
public void setMode(String mode) {
        if ("soft".equalsIgnoreCase(mode)) {
                this.mode = ResetType.SOFT;
        } else if ("mixed".equalsIgnoreCase(mode)) {
                this.mode = ResetType.MIXED;
        } else if ("hard".equalsIgnoreCase(mode)) {
                this.mode = ResetType.HARD;
        } else if ("merge".equalsIgnoreCase(mode)) {
                this.mode = ResetType.MERGE;
        } else if ("keep".equalsIgnoreCase(mode)) {
                this.mode = ResetType.KEEP;
        } else {
                this.mode = ResetType.MIXED;
        }
}
 

import org.eclipse.jgit.api.ResetCommand.ResetType; //导入依赖的package包/类
private void resetAndRemoveUntrackedFiles( final Git repository )
		throws GitAPIException, CheckoutConflictException {
	repository.clean() //
			.setCleanDirectories( true ) //
			.setForce( true ) //
			.setIgnore( false ) //
			.call(); //

	repository.reset() //
			.setMode( ResetType.HARD ) //
			.call(); //
}
 

import org.eclipse.jgit.api.ResetCommand.ResetType; //导入依赖的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.api.ResetCommand.ResetType; //导入依赖的package包/类
public void reset() {
	/* delete lock file if one is present */
	File f = new File(gitRepoPath + "/.git/index.lock");
	if(f.exists()) {
		f.delete();
	}
	
	/* reset --hard HEAD */
	try {
		git.reset().setMode(ResetType.HARD).call();
	} catch (Exception e) {
		e.printStackTrace();
	}
}
 

import org.eclipse.jgit.api.ResetCommand.ResetType; //导入依赖的package包/类
public void close() throws GitAPIException {
	Git git = gitRepository.getGit();
	git.reset().setMode(ResetType.HARD).call();

	if (indexUpdate != null) {
		indexUpdate.close();
	}
}
 

import org.eclipse.jgit.api.ResetCommand.ResetType; //导入依赖的package包/类
private void reset(Project project, Branch branch) throws Exception {

		logger.log(project, "git reset --hard origin/%s", branch);

		doWithGit(project, git -> {

			git.reset()//
					.setMode(ResetType.HARD)//
					.setRef("origin/".concat(branch.toString()))//
					.call();
		});
	}
 

import org.eclipse.jgit.api.ResetCommand.ResetType; //导入依赖的package包/类
@Override
public void reset(ResetParams params) throws GitException {
  try {
    ResetCommand resetCommand = getGit().reset();
    resetCommand.setRef(params.getCommit());
    List<String> patterns = params.getFilePattern();
    patterns.forEach(resetCommand::addPath);

    if (params.getType() != null && patterns.isEmpty()) {
      switch (params.getType()) {
        case HARD:
          resetCommand.setMode(ResetType.HARD);
          break;
        case KEEP:
          resetCommand.setMode(ResetType.KEEP);
          break;
        case MERGE:
          resetCommand.setMode(ResetType.MERGE);
          break;
        case MIXED:
          resetCommand.setMode(ResetType.MIXED);
          break;
        case SOFT:
          resetCommand.setMode(ResetType.SOFT);
          break;
      }
    }

    resetCommand.call();
  } catch (GitAPIException exception) {
    throw new GitException(exception.getMessage(), exception);
  }
}