/// <exception cref="NGit.Errors.MissingObjectException"></exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception> /// <exception cref="NGit.Api.Errors.JGitInternalException"></exception> private NGit.Api.LogCommand Add(bool include, AnyObjectId start) { CheckCallable(); try { if (include) { walk.MarkStart(walk.LookupCommit(start)); startSpecified = true; } else { walk.MarkUninteresting(walk.LookupCommit(start)); } return(this); } catch (MissingObjectException e) { throw; } catch (IncorrectObjectTypeException e) { throw; } catch (IOException e) { throw new JGitInternalException(MessageFormat.Format(JGitText.Get().exceptionOccuredDuringAddingOfOptionToALogCommand , start), e); } }
/// <summary>Configure the generator to compute reverse blame (history of deletes).</summary> /// <remarks> /// Configure the generator to compute reverse blame (history of deletes). /// <p> /// This method is expensive as it immediately runs a RevWalk over the /// history spanning the expression /// <code>start..end</code> /// (end being more recent /// than start) and then performs the equivalent operation as /// <see cref="Push(string, NGit.AnyObjectId)">Push(string, NGit.AnyObjectId)</see> /// to begin blame traversal from the /// commit named by /// <code>start</code> /// walking forwards through history until /// <code>end</code> /// blaming line deletions. /// <p> /// A reverse blame may produce multiple sources for the same result line, /// each of these is a descendant commit that removed the line, typically /// this occurs when the same deletion appears in multiple side branches such /// as due to a cherry-pick. Applications relying on reverse should use /// <see cref="BlameResult">BlameResult</see> /// as it filters these duplicate sources and only /// remembers the first (oldest) deletion. /// </remarks> /// <param name="start"> /// oldest commit to traverse from. The result file will be loaded /// from this commit's tree. /// </param> /// <param name="end"> /// most recent commits to stop traversal at. Usually an active /// branch tip, tag, or HEAD. /// </param> /// <returns> /// /// <code>this</code> /// </returns> /// <exception cref="System.IO.IOException">the repository cannot be read.</exception> public virtual NGit.Blame.BlameGenerator Reverse <_T0>(AnyObjectId start, ICollection <_T0> end) where _T0 : ObjectId { InitRevPool(true); ReverseWalk.ReverseCommit result = (ReverseWalk.ReverseCommit)revPool.ParseCommit (start); if (!Find(result, resultPath)) { return(this); } revPool.MarkUninteresting(result); foreach (ObjectId id in end) { revPool.MarkStart(revPool.ParseCommit(id)); } while (revPool.Next() != null) { } // just pump the queue Candidate.ReverseCandidate c = new Candidate.ReverseCandidate(result, resultPath); c.sourceBlob = idBuf.ToObjectId(); c.LoadText(reader); c.regionList = new Region(0, 0, c.sourceText.Size()); remaining = c.sourceText.Size(); Push(c); return(this); }
/// <summary> /// Find commits that are reachable from <code>start</code> until a commit /// that is reachable from <code>end</code> is encountered. /// </summary> /// <remarks> /// Find commits that are reachable from <code>start</code> until a commit /// that is reachable from <code>end</code> is encountered. In other words, /// Find of commits that are in <code>start</code>, but not in /// <code>end</code>. /// <p> /// Note that this method calls /// <see cref="RevWalk.Reset()">RevWalk.Reset()</see> /// at the beginning. /// Also note that the existing rev filter on the walk is left as-is, so be /// sure to set the right rev filter before calling this method. /// </remarks> /// <param name="walk">the rev walk to use</param> /// <param name="start">the commit to start counting from</param> /// <param name="end"> /// the commit where counting should end, or null if counting /// should be done until there are no more commits /// </param> /// <returns>the commits found</returns> /// <exception cref="NGit.Errors.MissingObjectException">NGit.Errors.MissingObjectException /// </exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException">NGit.Errors.IncorrectObjectTypeException /// </exception> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public static IList <RevCommit> Find(RevWalk walk, RevCommit start, RevCommit end) { walk.Reset(); walk.MarkStart(start); if (end != null) { walk.MarkUninteresting(end); } IList <RevCommit> commits = new AList <RevCommit>(); foreach (RevCommit c in walk) { commits.AddItem(c); } return(commits); }
/// <summary> /// Find commits that are reachable from <code>start</code> until a commit /// that is reachable from <code>end</code> is encountered. /// </summary> /// <remarks> /// Find commits that are reachable from <code>start</code> until a commit /// that is reachable from <code>end</code> is encountered. In other words, /// Find of commits that are in <code>start</code>, but not in /// <code>end</code>. /// <p> /// Note that this method calls /// <see cref="RevWalk.Reset()">RevWalk.Reset()</see> /// at the beginning. /// Also note that the existing rev filter on the walk is left as-is, so be /// sure to set the right rev filter before calling this method. /// </remarks> /// <param name="walk">the rev walk to use</param> /// <param name="start">the commit to start counting from</param> /// <param name="end"> /// the commit where counting should end, or null if counting /// should be done until there are no more commits /// </param> /// <returns>the commits found</returns> /// <exception cref="NGit.Errors.MissingObjectException">NGit.Errors.MissingObjectException /// </exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException">NGit.Errors.IncorrectObjectTypeException /// </exception> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public static IList<RevCommit> Find(RevWalk walk, RevCommit start, RevCommit end) { walk.Reset(); walk.MarkStart(start); if (end != null) { walk.MarkUninteresting(end); } IList<RevCommit> commits = new AList<RevCommit>(); foreach (RevCommit c in walk) { commits.AddItem(c); } return commits; }
/// <exception cref="System.Exception"></exception> protected internal virtual void MarkUninteresting(RevCommit commit) { rw.MarkUninteresting(commit); }
// Utility class /// <summary> /// Count the number of commits that are reachable from <code>start</code> /// until a commit that is reachable from <code>end</code> is encountered. /// </summary> /// <remarks> /// Count the number of commits that are reachable from <code>start</code> /// until a commit that is reachable from <code>end</code> is encountered. In /// other words, count the number of commits that are in <code>start</code>, /// but not in <code>end</code>. /// <p> /// Note that this method calls /// <see cref="RevWalk.Reset()">RevWalk.Reset()</see> /// at the beginning. /// Also note that the existing rev filter on the walk is left as-is, so be /// sure to set the right rev filter before calling this method. /// </remarks> /// <param name="walk">the rev walk to use</param> /// <param name="start">the commit to start counting from</param> /// <param name="end"> /// the commit where counting should end, or null if counting /// should be done until there are no more commits /// </param> /// <returns>the number of commits</returns> /// <exception cref="NGit.Errors.MissingObjectException">NGit.Errors.MissingObjectException /// </exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException">NGit.Errors.IncorrectObjectTypeException /// </exception> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public static int Count(RevWalk walk, RevCommit start, RevCommit end) { walk.Reset(); walk.MarkStart(start); if (end != null) { walk.MarkUninteresting(end); } int count = 0; for (RevCommit c = walk.Next(); c != null; c = walk.Next()) { count++; } return count; }