/// <summary>
/// Apply a flag to all commits matching the specified filter.
///
/// This version allows incremental testing and application, such as from a
/// background thread that needs to periodically halt processing and send
/// updates to the UI.
/// </summary>
/// <param name="matching">
/// the filter to test commits with. If the filter includes a
/// commit it will have the flag set; if the filter does not
/// include the commit the flag will be unset.
/// </param>
/// <param name="flag">
/// the flag to Apply (or remove). Applications are responsible
/// for allocating this flag from the source RevWalk.
/// </param>
/// <param name="rangeBegin">
/// first commit within the list to begin testing at, inclusive.
/// Must not be negative, but may be beyond the end of the list.
/// </param>
/// <param name="rangeEnd">
/// last commit within the list to end testing at, exclusive. If
/// smaller than or equal to <code>rangeBegin</code> then no
/// commits will be tested.
/// </param>
/// <remarks>
/// Revision filter needed to Read additional objects, but an
/// error occurred while reading the pack files or loose objects
/// of the repository.
/// </remarks>
public void applyFlag(RevFilter matching, RevFlag flag, int rangeBegin, int rangeEnd)
{
RevWalk w = flag.Walker;
rangeEnd = Math.Min(rangeEnd, Size);
while (rangeBegin < rangeEnd)
{
int index = rangeBegin;
Block s = Contents;
while (s.Shift > 0)
{
int i = index >> s.Shift;
index -= i << s.Shift;
s = (Block)s.Contents[i];
}
while (rangeBegin++ < rangeEnd && index < BLOCK_SIZE)
{
var c = (RevCommit)s.Contents[index++];
if (matching.include(w, c))
{
c.add(flag);
}
else
{
c.remove(flag);
}
}
}
}
public override bool include(RevWalk walker, RevCommit c)
{
return(!_a.include(walker, c));
}
public override RevCommit next()
{
try
{
while (true)
{
RevCommit c = _pending.next();
if (c == null)
{
_walker.WindowCursor.Release();
return(null);
}
bool produce = !((c.Flags & UNINTERESTING) != 0) && _filter.include(_walker, c);
foreach (RevCommit p in c.Parents)
{
if ((p.Flags & SEEN) != 0)
{
continue;
}
if ((p.Flags & PARSED) == 0)
{
p.parseHeaders(_walker);
}
p.Flags |= SEEN;
_pending.add(p);
}
_walker.carryFlagsImpl(c);
if ((c.Flags & UNINTERESTING) != 0)
{
if (_pending.everbodyHasFlag(UNINTERESTING))
{
RevCommit n = _pending.peek();
if (n != null && n.CommitTime >= _last.CommitTime)
{
// This is too close to call. The Next commit we
// would pop is dated After the last one produced.
// We have to keep going to ensure that we carry
// flags as much as necessary.
//
_overScan = OVER_SCAN;
}
else if (--_overScan == 0)
{
throw StopWalkException.INSTANCE;
}
}
else
{
_overScan = OVER_SCAN;
}
if (CanDispose)
{
c.DisposeBody();
}
continue;
}
if (produce)
{
return(_last = c);
}
if (CanDispose)
{
c.DisposeBody();
}
}
}
catch (StopWalkException)
{
_walker.WindowCursor.Release();
_pending.clear();
return(null);
}
}