/// <exception cref="System.IO.IOException"></exception>
private bool WantSatisfied(RevObject want)
{
if (want.Has(SATISFIED))
{
return(true);
}
walk.ResetRetain(SAVE);
walk.MarkStart((RevCommit)want);
if (oldestTime != 0)
{
walk.SetRevFilter(CommitTimeRevFilter.After(oldestTime * 1000L));
}
for (; ;)
{
RevCommit c = walk.Next();
if (c == null)
{
break;
}
if (c.Has(PEER_HAS))
{
AddCommonBase(c);
want.Add(SATISFIED);
return(true);
}
}
return(false);
}
/// <exception cref="System.IO.IOException"></exception>
private void MarkReachable(ICollection <ObjectId> have, int maxTime)
{
foreach (Ref r in local.GetAllRefs().Values)
{
try
{
RevCommit o = walk.ParseCommit(r.GetObjectId());
o.Add(REACHABLE);
reachableCommits.AddItem(o);
}
catch (IOException)
{
}
}
// If we cannot read the value of the ref skip it.
foreach (ObjectId id in have)
{
try
{
RevCommit o = walk.ParseCommit(id);
o.Add(REACHABLE);
reachableCommits.AddItem(o);
}
catch (IOException)
{
}
}
// If we cannot read the value of the ref skip it.
if (maxTime > 0)
{
// Mark reachable commits until we reach maxTime. These may
// wind up later matching up against things we want and we
// can avoid asking for something we already happen to have.
//
DateTime maxWhen = Sharpen.Extensions.CreateDate(maxTime * 1000L);
walk.Sort(RevSort.COMMIT_TIME_DESC);
walk.MarkStart(reachableCommits);
walk.SetRevFilter(CommitTimeRevFilter.After(maxWhen));
for (; ;)
{
RevCommit c = walk.Next();
if (c == null)
{
break;
}
if (c.Has(ADVERTISED) && !c.Has(COMMON))
{
// This is actually going to be a common commit, but
// our peer doesn't know that fact yet.
//
c.Add(COMMON);
c.Carry(COMMON);
reachableCommits.AddItem(c);
}
}
}
}
private void MarkReachable(IEnumerable <ObjectId> have, int maxTime)
{
foreach (Ref r in local.getAllRefs().Values)
{
try
{
RevCommit o = _walk.parseCommit(r.ObjectId);
o.add(REACHABLE);
_reachableCommits.add(o);
}
catch (IOException)
{
// If we cannot read the value of the ref skip it.
}
}
foreach (ObjectId id in have)
{
try
{
RevCommit o = _walk.parseCommit(id);
o.add(REACHABLE);
_reachableCommits.add(o);
}
catch (IOException)
{
// If we cannot read the value of the ref skip it.
}
}
if (maxTime > 0)
{
// Mark reachable commits until we reach maxTime. These may
// wind up later matching up against things we want and we
// can avoid asking for something we already happen to have.
//
DateTime maxWhen = (maxTime * 1000L).MillisToUtcDateTime();
_walk.sort(RevSort.COMMIT_TIME_DESC);
_walk.markStart(_reachableCommits);
_walk.setRevFilter(CommitTimeRevFilter.After(maxWhen));
for (; ;)
{
RevCommit c = _walk.next();
if (c == null)
{
break;
}
if (c.has(ADVERTISED) && !c.has(COMMON))
{
c.add(COMMON);
c.carry(COMMON);
_reachableCommits.add(c);
}
}
}
}
public string[] RetrieveAuthors(DateRange dateRange)
{
var revWalk = CreateRevWalker();
revWalk.SetRevFilter(CommitTimeRevFilter.Between(dateRange.StartDate.GetValueOrDefault(),
dateRange.EndDate.GetValueOrDefault()));
var commits = revWalk.ToArray();
return((from revision in commits select revision.GetAuthorIdent().GetName()).Distinct().ToArray());
}
public virtual void TestCommitTimeRevFilter()
{
RevCommit a = Commit();
Tick(100);
RevCommit b = Commit(a);
Tick(100);
DateTime since = GetClock();
RevCommit c1 = Commit(b);
Tick(100);
RevCommit c2 = Commit(b);
Tick(100);
DateTime until = GetClock();
RevCommit d = Commit(c1, c2);
Tick(100);
RevCommit e = Commit(d);
{
RevFilter after = CommitTimeRevFilter.After(since);
NUnit.Framework.Assert.IsNotNull(after);
rw.SetRevFilter(after);
MarkStart(e);
AssertCommit(e, rw.Next());
AssertCommit(d, rw.Next());
AssertCommit(c2, rw.Next());
AssertCommit(c1, rw.Next());
NUnit.Framework.Assert.IsNull(rw.Next());
}
{
RevFilter before = CommitTimeRevFilter.Before(until);
NUnit.Framework.Assert.IsNotNull(before);
rw.Reset();
rw.SetRevFilter(before);
MarkStart(e);
AssertCommit(c2, rw.Next());
AssertCommit(c1, rw.Next());
AssertCommit(b, rw.Next());
AssertCommit(a, rw.Next());
NUnit.Framework.Assert.IsNull(rw.Next());
}
{
RevFilter between = CommitTimeRevFilter.Between(since, until);
NUnit.Framework.Assert.IsNotNull(between);
rw.Reset();
rw.SetRevFilter(between);
MarkStart(e);
AssertCommit(c2, rw.Next());
AssertCommit(c1, rw.Next());
NUnit.Framework.Assert.IsNull(rw.Next());
}
}
/// <exception cref="System.IO.IOException"></exception>
private void MarkReachable(ICollection <ObjectId> have, int maxTime)
{
foreach (Ref r in local.GetAllRefs().Values)
{
ObjectId id = r.GetPeeledObjectId();
if (id == null)
{
id = r.GetObjectId();
}
if (id == null)
{
continue;
}
ParseReachable(id);
}
foreach (ObjectId id_1 in local.GetAdditionalHaves())
{
ParseReachable(id_1);
}
foreach (ObjectId id_2 in have)
{
ParseReachable(id_2);
}
if (maxTime > 0)
{
// Mark reachable commits until we reach maxTime. These may
// wind up later matching up against things we want and we
// can avoid asking for something we already happen to have.
//
DateTime maxWhen = Sharpen.Extensions.CreateDate(maxTime * 1000L);
walk.Sort(RevSort.COMMIT_TIME_DESC);
walk.MarkStart(reachableCommits);
walk.SetRevFilter(CommitTimeRevFilter.After(maxWhen));
for (; ;)
{
RevCommit c = walk.Next();
if (c == null)
{
break;
}
if (c.Has(ADVERTISED) && !c.Has(COMMON))
{
// This is actually going to be a common commit, but
// our peer doesn't know that fact yet.
//
c.Add(COMMON);
c.Carry(COMMON);
reachableCommits.AddItem(c);
}
}
}
}
private void MarkReachable(IEnumerable <ObjectId> have, int maxTime)
{
foreach (Ref r in local.getAllRefs().Values)
{
try
{
RevCommit o = _walk.parseCommit(r.ObjectId);
o.add(REACHABLE);
_reachableCommits.add(o);
}
catch (IOException)
{
}
}
foreach (ObjectId id in have)
{
try
{
RevCommit o = _walk.parseCommit(id);
o.add(REACHABLE);
_reachableCommits.add(o);
}
catch (IOException)
{
}
}
if (maxTime > 0)
{
DateTime maxWhen = new DateTime(1970, 1, 1) + TimeSpan.FromSeconds(maxTime);
_walk.sort(RevSort.COMMIT_TIME_DESC);
_walk.markStart(_reachableCommits);
_walk.setRevFilter(CommitTimeRevFilter.After(maxWhen));
for (; ;)
{
RevCommit c = _walk.next();
if (c == null)
{
break;
}
if (c.has(ADVERTISED) && !c.has(COMMON))
{
c.add(COMMON);
c.carry(COMMON);
_reachableCommits.add(c);
}
}
}
}
public RevisionInfo[] GetRevisions(RevisionId fromChangeset, RevisionId toChangeset)
{
var revWalk = CreateRevWalker();
try
{
RevFilter betweenFilter = CommitTimeRevFilter.Between(((GitRevisionId)fromChangeset).Time,
((GitRevisionId)toChangeset).Time);
revWalk.SetRevFilter(ApplyNoMergesFilter(betweenFilter));
var commits = revWalk.ToArray();
return(commits.Select(commit => commit.ConvertToRevisionInfo(_git.GetRepository())).ToArray());
}
finally
{
revWalk.Dispose();
}
}
public IEnumerable <RevisionRange> GetFromTillHead(DateTime from, int pageSize)
{
Fetch();
var revWalk = CreateRevWalker();
try
{
var filter = ApplyNoMergesFilter(CommitTimeRevFilter.After(from));
revWalk.SetRevFilter(filter);
var commits = (from revision in revWalk orderby revision.GetCommitTime() ascending select revision).ToArray().Split(pageSize);
var fromTillHead = commits.Select(x => new RevisionRange(x.First().ConvertToRevisionId(), x.Last().ConvertToRevisionId())).ToArray();
return(fromTillHead);
}
finally
{
revWalk.Dispose();
}
}
public IEnumerable <RevisionRange> GetFromAndBefore(RevisionId @from, RevisionId to, int pageSize)
{
Fetch();
var revWalk = CreateRevWalker();
try
{
var filter = CommitTimeRevFilter.Between(((GitRevisionId)from).Time.AddSeconds(1),
((GitRevisionId)to).Time.AddSeconds(-1));
revWalk.SetRevFilter(ApplyNoMergesFilter(filter));
var commits =
(from revision in revWalk orderby revision.GetCommitTime() ascending select revision).ToArray().Split(pageSize);
var fromTillHead =
commits.Select(x => new RevisionRange(x.First().ConvertToRevisionId(), x.Last().ConvertToRevisionId())).ToArray();
return(fromTillHead);
}
finally
{
revWalk.Dispose();
}
}
public void testCommitTimeRevFilter()
{
RevCommit a = Commit();
Tick(100);
RevCommit b = Commit(a);
Tick(100);
DateTime since = (nowTick).MillisToDateTime();
RevCommit c1 = Commit(b);
Tick(100);
RevCommit c2 = Commit(b);
Tick(100);
DateTime until = (nowTick).MillisToDateTime();
RevCommit d = Commit(c1, c2);
Tick(100);
RevCommit e = Commit(d);
{
RevFilter after = CommitTimeRevFilter.After(since);
Assert.IsNotNull(after);
rw.setRevFilter(after);
MarkStart(e);
AssertCommit(e, rw.next());
AssertCommit(d, rw.next());
AssertCommit(c2, rw.next());
AssertCommit(c1, rw.next());
Assert.IsNull(rw.next());
}
{
RevFilter before = CommitTimeRevFilter.Before(until);
Assert.IsNotNull(before);
rw.reset();
rw.setRevFilter(before);
MarkStart(e);
AssertCommit(c2, rw.next());
AssertCommit(c1, rw.next());
AssertCommit(b, rw.next());
AssertCommit(a, rw.next());
Assert.IsNull(rw.next());
}
{
RevFilter between = CommitTimeRevFilter.Between(since, until);
Assert.IsNotNull(between);
rw.reset();
rw.setRevFilter(between);
MarkStart(e);
AssertCommit(c2, rw.next());
AssertCommit(c1, rw.next());
Assert.IsNull(rw.next());
}
}
