Examples of org.eclipse.jgit.revwalk.RevWalk

org.eclipse.jgit.revwalk.RevWalk
Walks a commit graph and produces the matching commits in order.
A RevWalk instance can only be used once to generate results. Running a second time requires creating a new RevWalk instance, or invoking {@link #reset()} before starting again. Resetting an existing instance may befaster for some applications as commit body parsing can be avoided on the later invocations.
RevWalk instances are not thread-safe. Applications must either restrict usage of a RevWalk instance to a single thread, or implement their own synchronization at a higher level.
Multiple simultaneous RevWalk instances per {@link Repository} are permitted,even from concurrent threads. Equality of {@link RevCommit}s from two different RevWalk instances is never true, even if their {@link ObjectId}s are equal (and thus they describe the same commit).
The offered iterator is over the list of RevCommits described by the configuration of this instance. Applications should restrict themselves to using either the provided Iterator or {@link #next()}, but never use both on the same RevWalk at the same time. The Iterator may buffer RevCommits, while {@link #next()} does not.

        }
      }
    } finally {
      dc.unlock();
    }
    RevWalk rw = new RevWalk(repo);
    RevCommit commit = rw.parseCommit(repo.resolve(Constants.HEAD));
    rw.release();
    return commit;
  }

View Full Code Here

   *             upon internal failure
   */
  public List<Note> call() throws JGitInternalException {
    checkCallable();
    List<Note> notes = new ArrayList<Note>();
    RevWalk walk = new RevWalk(repo);
    NoteMap map = NoteMap.newEmptyMap();
    try {
      Ref ref = repo.getRef(notesRef);
      // if we have a notes ref, use it
      if (ref != null) {
        RevCommit notesCommit = walk.parseCommit(ref.getObjectId());
        map = NoteMap.read(walk.getObjectReader(), notesCommit);
      }


      Iterator<Note> i = map.iterator();
      while (i.hasNext())
        notes.add(i.next());
    } catch (IOException e) {
      throw new JGitInternalException(e.getMessage(), e);
    } finally {
      walk.release();
    }


    return notes;
  }

View Full Code Here

      }
    } finally {
      closeConnection(result);
    }


    final RevWalk walk = new RevWalk(transport.local);
    try {
      if (transport.isRemoveDeletedRefs())
        deleteStaleTrackingRefs(result, walk);
      for (TrackingRefUpdate u : localUpdates) {
        try {
          u.update(walk);
          result.add(u);
        } catch (IOException err) {
          throw new TransportException(MessageFormat.format(JGitText
              .get().failureUpdatingTrackingRef,
              u.getLocalName(), err.getMessage()), err);
        }
      }
    } finally {
      walk.release();
    }


    if (!fetchHeadUpdates.isEmpty()) {
      try {
        updateFETCH_HEAD(result);

View Full Code Here

   */
  public List<DiffEntry> scan(AnyObjectId a, AnyObjectId b)
      throws IOException {
    assertHaveRepository();


    RevWalk rw = new RevWalk(reader);
    return scan(rw.parseTree(a), rw.parseTree(b));
  }

View Full Code Here

   */
  public RevCommit call() throws GitAPIException {
    RevCommit newHead = null;
    checkCallable();


    RevWalk revWalk = new RevWalk(repo);
    try {


      // get the head commit
      Ref headRef = repo.getRef(Constants.HEAD);
      if (headRef == null)
        throw new NoHeadException(
            JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported);
      RevCommit headCommit = revWalk.parseCommit(headRef.getObjectId());


      newHead = headCommit;


      // loop through all refs to be reverted
      for (Ref src : commits) {
        // get the commit to be reverted
        // handle annotated tags
        ObjectId srcObjectId = src.getPeeledObjectId();
        if (srcObjectId == null)
          srcObjectId = src.getObjectId();
        RevCommit srcCommit = revWalk.parseCommit(srcObjectId);


        // get the parent of the commit to revert
        if (srcCommit.getParentCount() != 1) {
          throw new MultipleParentsNotAllowedException(
              JGitText.get().canOnlyRevertCommitsWithOneParent);
        }
        RevCommit srcParent = srcCommit.getParent(0);
        revWalk.parseHeaders(srcParent);


        ResolveMerger merger = (ResolveMerger) MergeStrategy.RESOLVE
            .newMerger(repo);
        merger.setWorkingTreeIterator(new FileTreeIterator(repo));
        merger.setBase(srcCommit.getTree());


        if (merger.merge(headCommit, srcParent)) {
          if (AnyObjectId.equals(headCommit.getTree().getId(), merger
              .getResultTreeId()))
            continue;
          DirCacheCheckout dco = new DirCacheCheckout(repo,
              headCommit.getTree(), repo.lockDirCache(),
              merger.getResultTreeId());
          dco.setFailOnConflict(true);
          dco.checkout();
          String newMessage = "Revert \""
              + srcCommit.getShortMessage() + "\"" + "\n\n"
              + "This reverts commit "
              + srcCommit.getId().getName() + ".\n";
          newHead = new Git(getRepository()).commit().setMessage(
              newMessage).call();
          revertedRefs.add(src);
        } else {
          return null;
        }
      }
    } catch (IOException e) {
      throw new JGitInternalException(
          MessageFormat.format(
                  JGitText.get().exceptionCaughtDuringExecutionOfRevertCommand,
              e), e);
    } finally {
      revWalk.release();
    }
    return newHead;
  }

View Full Code Here

   * @param copyFrom
   *            the source repository.
   */
  public UploadPack(final Repository copyFrom) {
    db = copyFrom;
    walk = new RevWalk(db);
    walk.setRetainBody(false);


    WANT = walk.newFlag("WANT");
    PEER_HAS = walk.newFlag("PEER_HAS");
    COMMON = walk.newFlag("COMMON");

View Full Code Here

            tagTargets.add(ref.getObjectId());
        }
        pw.setTagTargets(tagTargets);
      }


      RevWalk rw = walk;
      if (wantAll.isEmpty()) {
        pw.preparePack(pm, wantIds, commonBase);
      } else {
        walk.reset();


        ObjectWalk ow = walk.toObjectWalkWithSameObjects();
        pw.preparePack(pm, ow, wantAll, commonBase);
        rw = ow;
      }


      if (options.contains(OPTION_INCLUDE_TAG)) {
        for (Ref ref : refs.values()) {
          ObjectId objectId = ref.getObjectId();


          // If the object was already requested, skip it.
          if (wantAll.isEmpty()) {
            if (wantIds.contains(objectId))
              continue;
          } else {
            RevObject obj = rw.lookupOrNull(objectId);
            if (obj != null && obj.has(WANT))
              continue;
          }


          if (!ref.isPeeled())
            ref = db.peel(ref);


          ObjectId peeledId = ref.getPeeledObjectId();
          if (peeledId == null)
            continue;


          objectId = ref.getObjectId();
          if (pw.willInclude(peeledId) && !pw.willInclude(objectId))
            pw.addObject(rw.parseAny(objectId));
        }
      }


      pw.writePack(pm, NullProgressMonitor.INSTANCE, packOut);
      statistics = pw.getStatistics();

View Full Code Here

      revPool.release();


    if (reverse)
      revPool = new ReverseWalk(getRepository());
    else
      revPool = new RevWalk(getRepository());


    revPool.setRetainBody(true);
    SEEN = revPool.newFlag("SEEN");
    reader = revPool.getObjectReader();
    treeWalk = new TreeWalk(reader);

View Full Code Here

      Repository repo = git.getRepository();


      RevCommit newHead = null;
      List<Ref> cherryPickedRefs = new LinkedList<Ref>();


      RevWalk revWalk = new RevWalk(repo);
      try
      {
         // get the head commit
         Ref headRef = repo.getRef(Constants.HEAD);
         if (headRef == null)
            throw new NoHeadException(
                     JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported);
         RevCommit headCommit = revWalk.parseCommit(headRef.getObjectId());


         newHead = headCommit;


         // get the commit to be cherry-picked
         // handle annotated tags
         ObjectId srcObjectId = src.getPeeledObjectId();
         if (srcObjectId == null)
            srcObjectId = src.getObjectId();
         RevCommit srcCommit = revWalk.parseCommit(srcObjectId);


         // get the parent of the commit to cherry-pick
         if (srcCommit.getParentCount() == 0)
            throw new CantMergeCommitException("Commit with zero parents cannot be merged");


         if (srcCommit.getParentCount() > 1)
            throw new MultipleParentsNotAllowedException(
                     MessageFormat.format(
                              JGitText.get().canOnlyCherryPickCommitsWithOneParent,
                              srcCommit.name(),
                              Integer.valueOf(srcCommit.getParentCount())));


         RevCommit srcParent = srcCommit.getParent(0);
         revWalk.parseHeaders(srcParent);


         ResolveMerger merger = (ResolveMerger) MergeStrategy.RESOLVE
                  .newMerger(repo);
         merger.setWorkingTreeIterator(new FileTreeIterator(repo));
         merger.setBase(srcParent.getTree());
         if (merger.merge(headCommit, srcCommit))
         {
            DirCacheCheckout dco = new DirCacheCheckout(repo,
                     headCommit.getTree(), repo.lockDirCache(),
                     merger.getResultTreeId());
            dco.setFailOnConflict(true);
            dco.checkout();


            cherryPickedRefs.add(src);
         }
         else
         {
            if (merger.failed())
               return new CherryPickResult(merger.getFailingPaths());


            // there are merge conflicts
            String message = new MergeMessageFormatter()
                     .formatWithConflicts(srcCommit.getFullMessage(),
                              merger.getUnmergedPaths());


            repo.writeCherryPickHead(srcCommit.getId());
            repo.writeMergeCommitMsg(message);


            return CherryPickResult.CONFLICT;
         }
      }
      catch (IOException e)
      {
         throw new JGitInternalException(
                  MessageFormat.format(
                           JGitText.get().exceptionCaughtDuringExecutionOfCherryPickCommand,
                           e), e);
      }
      finally
      {
         revWalk.release();
      }


      return new CherryPickResult(newHead, cherryPickedRefs);
   }

View Full Code Here

   * @throws CorruptObjectException
   * @throws NoWorkTreeException
   */
  private Set<ObjectId> listNonHEADIndexObjects()
      throws CorruptObjectException, IOException {
    RevWalk revWalk = null;
    try {
      if (repo.getIndexFile() == null)
        return Collections.emptySet();
    } catch (NoWorkTreeException e) {
      return Collections.emptySet();
    }
    TreeWalk treeWalk = new TreeWalk(repo);
    try {
      treeWalk.addTree(new DirCacheIterator(repo.readDirCache()));
      ObjectId headID = repo.resolve(Constants.HEAD);
      if (headID != null) {
        revWalk = new RevWalk(repo);
        treeWalk.addTree(revWalk.parseTree(headID));
        revWalk.dispose();
        revWalk = null;
      }


      treeWalk.setFilter(TreeFilter.ANY_DIFF);
      treeWalk.setRecursive(true);
      Set<ObjectId> ret = new HashSet<ObjectId>();


      while (treeWalk.next()) {
        ObjectId objectId = treeWalk.getObjectId(0);
          switch (treeWalk.getRawMode(0) & FileMode.TYPE_MASK) {
            case FileMode.TYPE_MISSING:
            case FileMode.TYPE_GITLINK:
              continue;
            case FileMode.TYPE_TREE:
            case FileMode.TYPE_FILE:
            case FileMode.TYPE_SYMLINK:
              ret.add(objectId);
              continue;
            default:
          throw new IOException(MessageFormat.format(
              JGitText.get().corruptObjectInvalidMode3, String
                  .format("%o", Integer.valueOf(treeWalk
                      .getRawMode(0)),
                      (objectId == null) ? "null"
                          : objectId.name(), treeWalk
                      .getPathString(), repo
                      .getIndexFile())));
          }
        }
      return ret;
    } finally {
      if (revWalk != null)
        revWalk.dispose();
      treeWalk.release();
    }
  }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.eclipse.jgit.revwalk.RevWalk

com.atlassian.jgitflow.core.AbstractGitFlowCommand

com.atlassian.jgitflow.core.JGitFlowInitCommand

com.atlassian.jgitflow.core.util.GitHelper

com.gitblit.git.PatchsetReceivePack

com.gitblit.tickets.BranchTicketService

com.gitblit.utils.CompressionUtils

com.gitblit.utils.DiffUtils

com.gitblit.utils.JGitUtils

com.gitblit.utils.MetricUtils

com.gitblit.utils.RefLogUtils

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.