CheckoutCommand.java

  1. /*
  2.  * Copyright (C) 2010, Chris Aniszczyk <caniszczyk@gmail.com>
  3.  * Copyright (C) 2011, 2020 Matthias Sohn <matthias.sohn@sap.com> and others
  4.  *
  5.  * This program and the accompanying materials are made available under the
  6.  * terms of the Eclipse Distribution License v. 1.0 which is available at
  7.  * https://www.eclipse.org/org/documents/edl-v10.php.
  8.  *
  9.  * SPDX-License-Identifier: BSD-3-Clause
  10.  */
  11. package org.eclipse.jgit.api;

  13. import static org.eclipse.jgit.treewalk.TreeWalk.OperationType.CHECKOUT_OP;

  15. import java.io.IOException;
  16. import java.text.MessageFormat;
  17. import java.util.ArrayList;
  18. import java.util.EnumSet;
  19. import java.util.HashSet;
  20. import java.util.LinkedList;
  21. import java.util.List;
  22. import java.util.Set;

  24. import org.eclipse.jgit.api.CheckoutResult.Status;
  25. import org.eclipse.jgit.api.errors.CheckoutConflictException;
  26. import org.eclipse.jgit.api.errors.GitAPIException;
  27. import org.eclipse.jgit.api.errors.InvalidRefNameException;
  28. import org.eclipse.jgit.api.errors.JGitInternalException;
  29. import org.eclipse.jgit.api.errors.RefAlreadyExistsException;
  30. import org.eclipse.jgit.api.errors.RefNotFoundException;
  31. import org.eclipse.jgit.dircache.DirCache;
  32. import org.eclipse.jgit.dircache.DirCacheCheckout;
  33. import org.eclipse.jgit.dircache.DirCacheCheckout.CheckoutMetadata;
  34. import org.eclipse.jgit.dircache.DirCacheEditor;
  35. import org.eclipse.jgit.dircache.DirCacheEditor.PathEdit;
  36. import org.eclipse.jgit.dircache.DirCacheEntry;
  37. import org.eclipse.jgit.dircache.DirCacheIterator;
  38. import org.eclipse.jgit.errors.AmbiguousObjectException;
  39. import org.eclipse.jgit.errors.UnmergedPathException;
  40. import org.eclipse.jgit.events.WorkingTreeModifiedEvent;
  41. import org.eclipse.jgit.internal.JGitText;
  42. import org.eclipse.jgit.lib.AnyObjectId;
  43. import org.eclipse.jgit.lib.Constants;
  44. import org.eclipse.jgit.lib.CoreConfig.EolStreamType;
  45. import org.eclipse.jgit.lib.FileMode;
  46. import org.eclipse.jgit.lib.NullProgressMonitor;
  47. import org.eclipse.jgit.lib.ObjectId;
  48. import org.eclipse.jgit.lib.ObjectReader;
  49. import org.eclipse.jgit.lib.ProgressMonitor;
  50. import org.eclipse.jgit.lib.Ref;
  51. import org.eclipse.jgit.lib.RefUpdate;
  52. import org.eclipse.jgit.lib.RefUpdate.Result;
  53. import org.eclipse.jgit.lib.Repository;
  54. import org.eclipse.jgit.revwalk.RevCommit;
  55. import org.eclipse.jgit.revwalk.RevTree;
  56. import org.eclipse.jgit.revwalk.RevWalk;
  57. import org.eclipse.jgit.treewalk.TreeWalk;
  58. import org.eclipse.jgit.treewalk.WorkingTreeOptions;
  59. import org.eclipse.jgit.treewalk.filter.PathFilterGroup;

  61. /**
  62.  * Checkout a branch to the working tree.
  63.  * <p>
  64.  * Examples (<code>git</code> is a {@link org.eclipse.jgit.api.Git} instance):
  65.  * <p>
  66.  * Check out an existing branch:
  67.  *
  68.  * <pre>
  69.  * git.checkout().setName(&quot;feature&quot;).call();
  70.  * </pre>
  71.  * <p>
  72.  * Check out paths from the index:
  73.  *
  74.  * <pre>
  75.  * git.checkout().addPath(&quot;file1.txt&quot;).addPath(&quot;file2.txt&quot;).call();
  76.  * </pre>
  77.  * <p>
  78.  * Check out a path from a commit:
  79.  *
  80.  * <pre>
  81.  * git.checkout().setStartPoint(&quot;HEAD&circ;&quot;).addPath(&quot;file1.txt&quot;).call();
  82.  * </pre>
  83.  *
  84.  * <p>
  85.  * Create a new branch and check it out:
  86.  *
  87.  * <pre>
  88.  * git.checkout().setCreateBranch(true).setName(&quot;newbranch&quot;).call();
  89.  * </pre>
  90.  * <p>
  91.  * Create a new tracking branch for a remote branch and check it out:
  92.  *
  93.  * <pre>
  94.  * git.checkout().setCreateBranch(true).setName(&quot;stable&quot;)
  95.  *      .setUpstreamMode(SetupUpstreamMode.SET_UPSTREAM)
  96.  *      .setStartPoint(&quot;origin/stable&quot;).call();
  97.  * </pre>
  98.  *
  99.  * @see <a href=
  100.  *      "http://www.kernel.org/pub/software/scm/git/docs/git-checkout.html" >Git
  101.  *      documentation about Checkout</a>
  102.  */
  103. public class CheckoutCommand extends GitCommand<Ref> {

  105.     /**
  106.      * Stage to check out, see {@link CheckoutCommand#setStage(Stage)}.
  107.      */
  108.     public enum Stage {
  109.         /**
  110.          * Base stage (#1)
  111.          */
  112.         BASE(DirCacheEntry.STAGE_1),

  114.         /**
  115.          * Ours stage (#2)
  116.          */
  117.         OURS(DirCacheEntry.STAGE_2),

  119.         /**
  120.          * Theirs stage (#3)
  121.          */
  122.         THEIRS(DirCacheEntry.STAGE_3);

  124.         private final int number;

  126.         private Stage(int number) {
  127.             this.number = number;
  128.         }
  129.     }

  131.     private String name;

  133.     private boolean forceRefUpdate = false;

  135.     private boolean forced = false;

  137.     private boolean createBranch = false;

  139.     private boolean orphan = false;

  141.     private CreateBranchCommand.SetupUpstreamMode upstreamMode;

  143.     private String startPoint = null;

  145.     private RevCommit startCommit;

  147.     private Stage checkoutStage = null;

  149.     private CheckoutResult status;

  151.     private List<String> paths;

  153.     private boolean checkoutAllPaths;

  155.     private Set<String> actuallyModifiedPaths;

  157.     private ProgressMonitor monitor = NullProgressMonitor.INSTANCE;

  159.     /**
  160.      * Constructor for CheckoutCommand
  161.      *
  162.      * @param repo
  163.      *            the {@link org.eclipse.jgit.lib.Repository}
  164.      */
  165.     protected CheckoutCommand(Repository repo) {
  166.         super(repo);
  167.         this.paths = new LinkedList<>();
  168.     }

  170.     /** {@inheritDoc} */
  171.     @Override
  172.     public Ref call() throws GitAPIException, RefAlreadyExistsException,
  173.             RefNotFoundException, InvalidRefNameException,
  174.             CheckoutConflictException {
  175.         checkCallable();
  176.         try {
  177.             processOptions();
  178.             if (checkoutAllPaths || !paths.isEmpty()) {
  179.                 checkoutPaths();
  180.                 status = new CheckoutResult(Status.OK, paths);
  181.                 setCallable(false);
  182.                 return null;
  183.             }

  185.             if (createBranch) {
  186.                 try (Git git = new Git(repo)) {
  187.                     CreateBranchCommand command = git.branchCreate();
  188.                     command.setName(name);
  189.                     if (startCommit != null)
  190.                         command.setStartPoint(startCommit);
  191.                     else
  192.                         command.setStartPoint(startPoint);
  193.                     if (upstreamMode != null)
  194.                         command.setUpstreamMode(upstreamMode);
  195.                     command.call();
  196.                 }
  197.             }

  199.             Ref headRef = repo.exactRef(Constants.HEAD);
  200.             if (headRef == null) {
  201.                 // TODO Git CLI supports checkout from unborn branch, we should
  202.                 // also allow this
  203.                 throw new UnsupportedOperationException(
  204.                         JGitText.get().cannotCheckoutFromUnbornBranch);
  205.             }
  206.             String shortHeadRef = getShortBranchName(headRef);
  207.             String refLogMessage = "checkout: moving from " + shortHeadRef; //$NON-NLS-1$
  208.             ObjectId branch;
  209.             if (orphan) {
  210.                 if (startPoint == null && startCommit == null) {
  211.                     Result r = repo.updateRef(Constants.HEAD).link(
  212.                             getBranchName());
  213.                     if (!EnumSet.of(Result.NEW, Result.FORCED).contains(r))
  214.                         throw new JGitInternalException(MessageFormat.format(
  215.                                 JGitText.get().checkoutUnexpectedResult,
  216.                                 r.name()));
  217.                     this.status = CheckoutResult.NOT_TRIED_RESULT;
  218.                     return repo.exactRef(Constants.HEAD);
  219.                 }
  220.                 branch = getStartPointObjectId();
  221.             } else {
  222.                 branch = repo.resolve(name);
  223.                 if (branch == null)
  224.                     throw new RefNotFoundException(MessageFormat.format(
  225.                             JGitText.get().refNotResolved, name));
  226.             }

  228.             RevCommit headCommit = null;
  229.             RevCommit newCommit = null;
  230.             try (RevWalk revWalk = new RevWalk(repo)) {
  231.                 AnyObjectId headId = headRef.getObjectId();
  232.                 headCommit = headId == null ? null
  233.                         : revWalk.parseCommit(headId);
  234.                 newCommit = revWalk.parseCommit(branch);
  235.             }
  236.             RevTree headTree = headCommit == null ? null : headCommit.getTree();
  237.             DirCacheCheckout dco;
  238.             DirCache dc = repo.lockDirCache();
  239.             try {
  240.                 dco = new DirCacheCheckout(repo, headTree, dc,
  241.                         newCommit.getTree());
  242.                 dco.setFailOnConflict(true);
  243.                 dco.setForce(forced);
  244.                 if (forced) {
  245.                     dco.setFailOnConflict(false);
  246.                 }
  247.                 dco.setProgressMonitor(monitor);
  248.                 try {
  249.                     dco.checkout();
  250.                 } catch (org.eclipse.jgit.errors.CheckoutConflictException e) {
  251.                     status = new CheckoutResult(Status.CONFLICTS,
  252.                             dco.getConflicts());
  253.                     throw new CheckoutConflictException(dco.getConflicts(), e);
  254.                 }
  255.             } finally {
  256.                 dc.unlock();
  257.             }
  258.             Ref ref = repo.findRef(name);
  259.             if (ref != null && !ref.getName().startsWith(Constants.R_HEADS))
  260.                 ref = null;
  261.             String toName = Repository.shortenRefName(name);
  262.             RefUpdate refUpdate = repo.updateRef(Constants.HEAD, ref == null);
  263.             refUpdate.setForceUpdate(forceRefUpdate);
  264.             refUpdate.setRefLogMessage(refLogMessage + " to " + toName, false); //$NON-NLS-1$
  265.             Result updateResult;
  266.             if (ref != null)
  267.                 updateResult = refUpdate.link(ref.getName());
  268.             else if (orphan) {
  269.                 updateResult = refUpdate.link(getBranchName());
  270.                 ref = repo.exactRef(Constants.HEAD);
  271.             } else {
  272.                 refUpdate.setNewObjectId(newCommit);
  273.                 updateResult = refUpdate.forceUpdate();
  274.             }

  276.             setCallable(false);

  278.             boolean ok = false;
  279.             switch (updateResult) {
  280.             case NEW:
  281.                 ok = true;
  282.                 break;
  283.             case NO_CHANGE:
  284.             case FAST_FORWARD:
  285.             case FORCED:
  286.                 ok = true;
  287.                 break;
  288.             default:
  289.                 break;
  290.             }

  292.             if (!ok)
  293.                 throw new JGitInternalException(MessageFormat.format(JGitText
  294.                         .get().checkoutUnexpectedResult, updateResult.name()));


  297.             if (!dco.getToBeDeleted().isEmpty()) {
  298.                 status = new CheckoutResult(Status.NONDELETED,
  299.                         dco.getToBeDeleted(),
  300.                         new ArrayList<>(dco.getUpdated().keySet()),
  301.                         dco.getRemoved());
  302.             } else
  303.                 status = new CheckoutResult(new ArrayList<>(dco
  304.                         .getUpdated().keySet()), dco.getRemoved());

  306.             return ref;
  307.         } catch (IOException ioe) {
  308.             throw new JGitInternalException(ioe.getMessage(), ioe);
  309.         } finally {
  310.             if (status == null)
  311.                 status = CheckoutResult.ERROR_RESULT;
  312.         }
  313.     }

  315.     private String getShortBranchName(Ref headRef) {
  316.         if (headRef.isSymbolic()) {
  317.             return Repository.shortenRefName(headRef.getTarget().getName());
  318.         }
  319.         // Detached HEAD. Every non-symbolic ref in the ref database has an
  320.         // object id, so this cannot be null.
  321.         ObjectId id = headRef.getObjectId();
  322.         if (id == null) {
  323.             throw new NullPointerException();
  324.         }
  325.         return id.getName();
  326.     }

  328.     /**
  329.      * @param monitor
  330.      *            a progress monitor
  331.      * @return this instance
  332.      * @since 4.11
  333.      */
  334.     public CheckoutCommand setProgressMonitor(ProgressMonitor monitor) {
  335.         if (monitor == null) {
  336.             monitor = NullProgressMonitor.INSTANCE;
  337.         }
  338.         this.monitor = monitor;
  339.         return this;
  340.     }

  342.     /**
  343.      * Add a single slash-separated path to the list of paths to check out. To
  344.      * check out all paths, use {@link #setAllPaths(boolean)}.
  345.      * <p>
  346.      * If this option is set, neither the {@link #setCreateBranch(boolean)} nor
  347.      * {@link #setName(String)} option is considered. In other words, these
  348.      * options are exclusive.
  349.      *
  350.      * @param path
  351.      *            path to update in the working tree and index (with
  352.      *            <code>/</code> as separator)
  353.      * @return {@code this}
  354.      */
  355.     public CheckoutCommand addPath(String path) {
  356.         checkCallable();
  357.         this.paths.add(path);
  358.         return this;
  359.     }

  361.     /**
  362.      * Add multiple slash-separated paths to the list of paths to check out. To
  363.      * check out all paths, use {@link #setAllPaths(boolean)}.
  364.      * <p>
  365.      * If this option is set, neither the {@link #setCreateBranch(boolean)} nor
  366.      * {@link #setName(String)} option is considered. In other words, these
  367.      * options are exclusive.
  368.      *
  369.      * @param p
  370.      *            paths to update in the working tree and index (with
  371.      *            <code>/</code> as separator)
  372.      * @return {@code this}
  373.      * @since 4.6
  374.      */
  375.     public CheckoutCommand addPaths(List<String> p) {
  376.         checkCallable();
  377.         this.paths.addAll(p);
  378.         return this;
  379.     }

  381.     /**
  382.      * Set whether to checkout all paths.
  383.      * <p>
  384.      * This options should be used when you want to do a path checkout on the
  385.      * entire repository and so calling {@link #addPath(String)} is not possible
  386.      * since empty paths are not allowed.
  387.      * <p>
  388.      * If this option is set, neither the {@link #setCreateBranch(boolean)} nor
  389.      * {@link #setName(String)} option is considered. In other words, these
  390.      * options are exclusive.
  391.      *
  392.      * @param all
  393.      *            <code>true</code> to checkout all paths, <code>false</code>
  394.      *            otherwise
  395.      * @return {@code this}
  396.      * @since 2.0
  397.      */
  398.     public CheckoutCommand setAllPaths(boolean all) {
  399.         checkoutAllPaths = all;
  400.         return this;
  401.     }

  403.     /**
  404.      * Checkout paths into index and working directory, firing a
  405.      * {@link org.eclipse.jgit.events.WorkingTreeModifiedEvent} if the working
  406.      * tree was modified.
  407.      *
  408.      * @return this instance
  409.      * @throws java.io.IOException
  410.      * @throws org.eclipse.jgit.api.errors.RefNotFoundException
  411.      */
  412.     protected CheckoutCommand checkoutPaths() throws IOException,
  413.             RefNotFoundException {
  414.         actuallyModifiedPaths = new HashSet<>();
  415.         WorkingTreeOptions options = repo.getConfig()
  416.                 .get(WorkingTreeOptions.KEY);
  417.         DirCache dc = repo.lockDirCache();
  418.         try (RevWalk revWalk = new RevWalk(repo);
  419.                 TreeWalk treeWalk = new TreeWalk(repo,
  420.                         revWalk.getObjectReader())) {
  421.             treeWalk.setRecursive(true);
  422.             if (!checkoutAllPaths)
  423.                 treeWalk.setFilter(PathFilterGroup.createFromStrings(paths));
  424.             if (isCheckoutIndex())
  425.                 checkoutPathsFromIndex(treeWalk, dc, options);
  426.             else {
  427.                 RevCommit commit = revWalk.parseCommit(getStartPointObjectId());
  428.                 checkoutPathsFromCommit(treeWalk, dc, commit, options);
  429.             }
  430.         } finally {
  431.             try {
  432.                 dc.unlock();
  433.             } finally {
  434.                 WorkingTreeModifiedEvent event = new WorkingTreeModifiedEvent(
  435.                         actuallyModifiedPaths, null);
  436.                 actuallyModifiedPaths = null;
  437.                 if (!event.isEmpty()) {
  438.                     repo.fireEvent(event);
  439.                 }
  440.             }
  441.         }
  442.         return this;
  443.     }

  445.     private void checkoutPathsFromIndex(TreeWalk treeWalk, DirCache dc,
  446.             WorkingTreeOptions options)
  447.             throws IOException {
  448.         DirCacheIterator dci = new DirCacheIterator(dc);
  449.         treeWalk.addTree(dci);

  451.         String previousPath = null;

  453.         final ObjectReader r = treeWalk.getObjectReader();
  454.         DirCacheEditor editor = dc.editor();
  455.         while (treeWalk.next()) {
  456.             String path = treeWalk.getPathString();
  457.             // Only add one edit per path
  458.             if (path.equals(previousPath))
  459.                 continue;

  461.             final EolStreamType eolStreamType = treeWalk
  462.                     .getEolStreamType(CHECKOUT_OP);
  463.             final String filterCommand = treeWalk
  464.                     .getFilterCommand(Constants.ATTR_FILTER_TYPE_SMUDGE);
  465.             editor.add(new PathEdit(path) {
  466.                 @Override
  467.                 public void apply(DirCacheEntry ent) {
  468.                     int stage = ent.getStage();
  469.                     if (stage > DirCacheEntry.STAGE_0) {
  470.                         if (checkoutStage != null) {
  471.                             if (stage == checkoutStage.number) {
  472.                                 checkoutPath(ent, r, options,
  473.                                         new CheckoutMetadata(eolStreamType,
  474.                                                 filterCommand));
  475.                                 actuallyModifiedPaths.add(path);
  476.                             }
  477.                         } else {
  478.                             UnmergedPathException e = new UnmergedPathException(
  479.                                     ent);
  480.                             throw new JGitInternalException(e.getMessage(), e);
  481.                         }
  482.                     } else {
  483.                         checkoutPath(ent, r, options,
  484.                                 new CheckoutMetadata(eolStreamType,
  485.                                         filterCommand));
  486.                         actuallyModifiedPaths.add(path);
  487.                     }
  488.                 }
  489.             });

  491.             previousPath = path;
  492.         }
  493.         editor.commit();
  494.     }

  496.     private void checkoutPathsFromCommit(TreeWalk treeWalk, DirCache dc,
  497.             RevCommit commit, WorkingTreeOptions options) throws IOException {
  498.         treeWalk.addTree(commit.getTree());
  499.         final ObjectReader r = treeWalk.getObjectReader();
  500.         DirCacheEditor editor = dc.editor();
  501.         while (treeWalk.next()) {
  502.             final ObjectId blobId = treeWalk.getObjectId(0);
  503.             final FileMode mode = treeWalk.getFileMode(0);
  504.             final EolStreamType eolStreamType = treeWalk
  505.                     .getEolStreamType(CHECKOUT_OP);
  506.             final String filterCommand = treeWalk
  507.                     .getFilterCommand(Constants.ATTR_FILTER_TYPE_SMUDGE);
  508.             final String path = treeWalk.getPathString();
  509.             editor.add(new PathEdit(path) {
  510.                 @Override
  511.                 public void apply(DirCacheEntry ent) {
  512.                     if (ent.getStage() != DirCacheEntry.STAGE_0) {
  513.                         // A checkout on a conflicting file stages the checked
  514.                         // out file and resolves the conflict.
  515.                         ent.setStage(DirCacheEntry.STAGE_0);
  516.                     }
  517.                     ent.setObjectId(blobId);
  518.                     ent.setFileMode(mode);
  519.                     checkoutPath(ent, r, options,
  520.                             new CheckoutMetadata(eolStreamType, filterCommand));
  521.                     actuallyModifiedPaths.add(path);
  522.                 }
  523.             });
  524.         }
  525.         editor.commit();
  526.     }

  528.     private void checkoutPath(DirCacheEntry entry, ObjectReader reader,
  529.             WorkingTreeOptions options, CheckoutMetadata checkoutMetadata) {
  530.         try {
  531.             DirCacheCheckout.checkoutEntry(repo, entry, reader, true,
  532.                     checkoutMetadata, options);
  533.         } catch (IOException e) {
  534.             throw new JGitInternalException(MessageFormat.format(
  535.                     JGitText.get().checkoutConflictWithFile,
  536.                     entry.getPathString()), e);
  537.         }
  538.     }

  540.     private boolean isCheckoutIndex() {
  541.         return startCommit == null && startPoint == null;
  542.     }

  544.     private ObjectId getStartPointObjectId() throws AmbiguousObjectException,
  545.             RefNotFoundException, IOException {
  546.         if (startCommit != null)
  547.             return startCommit.getId();

  549.         String startPointOrHead = (startPoint != null) ? startPoint
  550.                 : Constants.HEAD;
  551.         ObjectId result = repo.resolve(startPointOrHead);
  552.         if (result == null)
  553.             throw new RefNotFoundException(MessageFormat.format(
  554.                     JGitText.get().refNotResolved, startPointOrHead));
  555.         return result;
  556.     }

  558.     private void processOptions() throws InvalidRefNameException,
  559.             RefAlreadyExistsException, IOException {
  560.         if (((!checkoutAllPaths && paths.isEmpty()) || orphan)
  561.                 && (name == null || !Repository
  562.                         .isValidRefName(Constants.R_HEADS + name)))
  563.             throw new InvalidRefNameException(MessageFormat.format(JGitText
  564.                     .get().branchNameInvalid, name == null ? "<null>" : name)); //$NON-NLS-1$

  566.         if (orphan) {
  567.             Ref refToCheck = repo.exactRef(getBranchName());
  568.             if (refToCheck != null)
  569.                 throw new RefAlreadyExistsException(MessageFormat.format(
  570.                         JGitText.get().refAlreadyExists, name));
  571.         }
  572.     }

  574.     private String getBranchName() {
  575.         if (name.startsWith(Constants.R_REFS))
  576.             return name;

  578.         return Constants.R_HEADS + name;
  579.     }

  581.     /**
  582.      * Specify the name of the branch or commit to check out, or the new branch
  583.      * name.
  584.      * <p>
  585.      * When only checking out paths and not switching branches, use
  586.      * {@link #setStartPoint(String)} or {@link #setStartPoint(RevCommit)} to
  587.      * specify from which branch or commit to check out files.
  588.      * <p>
  589.      * When {@link #setCreateBranch(boolean)} is set to <code>true</code>, use
  590.      * this method to set the name of the new branch to create and
  591.      * {@link #setStartPoint(String)} or {@link #setStartPoint(RevCommit)} to
  592.      * specify the start point of the branch.
  593.      *
  594.      * @param name
  595.      *            the name of the branch or commit
  596.      * @return this instance
  597.      */
  598.     public CheckoutCommand setName(String name) {
  599.         checkCallable();
  600.         this.name = name;
  601.         return this;
  602.     }

  604.     /**
  605.      * Specify whether to create a new branch.
  606.      * <p>
  607.      * If <code>true</code> is used, the name of the new branch must be set
  608.      * using {@link #setName(String)}. The commit at which to start the new
  609.      * branch can be set using {@link #setStartPoint(String)} or
  610.      * {@link #setStartPoint(RevCommit)}; if not specified, HEAD is used. Also
  611.      * see {@link #setUpstreamMode} for setting up branch tracking.
  612.      *
  613.      * @param createBranch
  614.      *            if <code>true</code> a branch will be created as part of the
  615.      *            checkout and set to the specified start point
  616.      * @return this instance
  617.      */
  618.     public CheckoutCommand setCreateBranch(boolean createBranch) {
  619.         checkCallable();
  620.         this.createBranch = createBranch;
  621.         return this;
  622.     }

  624.     /**
  625.      * Specify whether to create a new orphan branch.
  626.      * <p>
  627.      * If <code>true</code> is used, the name of the new orphan branch must be
  628.      * set using {@link #setName(String)}. The commit at which to start the new
  629.      * orphan branch can be set using {@link #setStartPoint(String)} or
  630.      * {@link #setStartPoint(RevCommit)}; if not specified, HEAD is used.
  631.      *
  632.      * @param orphan
  633.      *            if <code>true</code> a orphan branch will be created as part
  634.      *            of the checkout to the specified start point
  635.      * @return this instance
  636.      * @since 3.3
  637.      */
  638.     public CheckoutCommand setOrphan(boolean orphan) {
  639.         checkCallable();
  640.         this.orphan = orphan;
  641.         return this;
  642.     }

  644.     /**
  645.      * Specify to force the ref update in case of a branch switch.
  646.      *
  647.      * @param force
  648.      *            if <code>true</code> and the branch with the given name
  649.      *            already exists, the start-point of an existing branch will be
  650.      *            set to a new start-point; if false, the existing branch will
  651.      *            not be changed
  652.      * @return this instance
  653.      * @deprecated this method was badly named comparing its semantics to native
  654.      *             git's checkout --force option, use
  655.      *             {@link #setForceRefUpdate(boolean)} instead
  656.      */
  657.     @Deprecated
  658.     public CheckoutCommand setForce(boolean force) {
  659.         return setForceRefUpdate(force);
  660.     }

  662.     /**
  663.      * Specify to force the ref update in case of a branch switch.
  664.      *
  665.      * In releases prior to 5.2 this method was called setForce() but this name
  666.      * was misunderstood to implement native git's --force option, which is not
  667.      * true.
  668.      *
  669.      * @param forceRefUpdate
  670.      *            if <code>true</code> and the branch with the given name
  671.      *            already exists, the start-point of an existing branch will be
  672.      *            set to a new start-point; if false, the existing branch will
  673.      *            not be changed
  674.      * @return this instance
  675.      * @since 5.3
  676.      */
  677.     public CheckoutCommand setForceRefUpdate(boolean forceRefUpdate) {
  678.         checkCallable();
  679.         this.forceRefUpdate = forceRefUpdate;
  680.         return this;
  681.     }

  683.     /**
  684.      * Allow a checkout even if the workingtree or index differs from HEAD. This
  685.      * matches native git's '--force' option.
  686.      *
  687.      * JGit releases before 5.2 had a method <code>setForce()</code> offering
  688.      * semantics different from this new <code>setForced()</code>. This old
  689.      * semantic can now be found in {@link #setForceRefUpdate(boolean)}
  690.      *
  691.      * @param forced
  692.      *            if set to <code>true</code> then allow the checkout even if
  693.      *            workingtree or index doesn't match HEAD. Overwrite workingtree
  694.      *            files and index content with the new content in this case.
  695.      * @return this instance
  696.      * @since 5.3
  697.      */
  698.     public CheckoutCommand setForced(boolean forced) {
  699.         checkCallable();
  700.         this.forced = forced;
  701.         return this;
  702.     }

  704.     /**
  705.      * Set the name of the commit that should be checked out.
  706.      * <p>
  707.      * When checking out files and this is not specified or <code>null</code>,
  708.      * the index is used.
  709.      * <p>
  710.      * When creating a new branch, this will be used as the start point. If not
  711.      * specified or <code>null</code>, the current HEAD is used.
  712.      *
  713.      * @param startPoint
  714.      *            commit name to check out
  715.      * @return this instance
  716.      */
  717.     public CheckoutCommand setStartPoint(String startPoint) {
  718.         checkCallable();
  719.         this.startPoint = startPoint;
  720.         this.startCommit = null;
  721.         checkOptions();
  722.         return this;
  723.     }

  725.     /**
  726.      * Set the commit that should be checked out.
  727.      * <p>
  728.      * When creating a new branch, this will be used as the start point. If not
  729.      * specified or <code>null</code>, the current HEAD is used.
  730.      * <p>
  731.      * When checking out files and this is not specified or <code>null</code>,
  732.      * the index is used.
  733.      *
  734.      * @param startCommit
  735.      *            commit to check out
  736.      * @return this instance
  737.      */
  738.     public CheckoutCommand setStartPoint(RevCommit startCommit) {
  739.         checkCallable();
  740.         this.startCommit = startCommit;
  741.         this.startPoint = null;
  742.         checkOptions();
  743.         return this;
  744.     }

  746.     /**
  747.      * When creating a branch with {@link #setCreateBranch(boolean)}, this can
  748.      * be used to configure branch tracking.
  749.      *
  750.      * @param mode
  751.      *            corresponds to the --track/--no-track options; may be
  752.      *            <code>null</code>
  753.      * @return this instance
  754.      */
  755.     public CheckoutCommand setUpstreamMode(
  756.             CreateBranchCommand.SetupUpstreamMode mode) {
  757.         checkCallable();
  758.         this.upstreamMode = mode;
  759.         return this;
  760.     }

  762.     /**
  763.      * When checking out the index, check out the specified stage (ours or
  764.      * theirs) for unmerged paths.
  765.      * <p>
  766.      * This can not be used when checking out a branch, only when checking out
  767.      * the index.
  768.      *
  769.      * @param stage
  770.      *            the stage to check out
  771.      * @return this
  772.      */
  773.     public CheckoutCommand setStage(Stage stage) {
  774.         checkCallable();
  775.         this.checkoutStage = stage;
  776.         checkOptions();
  777.         return this;
  778.     }

  780.     /**
  781.      * Get the result, never <code>null</code>
  782.      *
  783.      * @return the result, never <code>null</code>
  784.      */
  785.     public CheckoutResult getResult() {
  786.         if (status == null)
  787.             return CheckoutResult.NOT_TRIED_RESULT;
  788.         return status;
  789.     }

  791.     private void checkOptions() {
  792.         if (checkoutStage != null && !isCheckoutIndex())
  793.             throw new IllegalStateException(
  794.                     JGitText.get().cannotCheckoutOursSwitchBranch);
  795.     }
  796. }
Created with JaCoCo 0.8.7.202105040129