void GetMovementInfos(NodeAtTime node, long toRevision, ref IList <MovementInfo> list, NodeAtTime initialNode = null)
{
// TODO document what initial node means
if (initialNode == null)
{
initialNode = node;
}
else if (initialNode == node)
{
return;
}
if (node.DeleteRevision.HasValue && node.DeleteRevision.Value <= toRevision)
{
list.Add(new MovementInfo(MovementAction.Delete, node.Path, node.Path, node.DeleteRevision.Value, node.DeleteRevision.Value));
}
if (node.Ancestor == null)
{
list.Add(new MovementInfo(MovementAction.Add, node.Path, node.Path, node.AddRevision, node.AddRevision));
}
else
{
if (node.Ancestor.Ancestor.DeleteRevision.HasValue && node.Ancestor.Ancestor.DeleteRevision.Value == node.AddRevision)
{
list.Add(new MovementInfo(MovementAction.Move, node.Ancestor.Ancestor.Path, node.Path, node.Ancestor.CopiedAtRevision, node.AddRevision));
}
else
{
list.Add(new MovementInfo(MovementAction.Copy, node.Ancestor.Ancestor.Path, node.Path, node.Ancestor.CopiedAtRevision, node.AddRevision));
}
GetMovementInfos(node.Ancestor.Ancestor, node.Ancestor.CopiedAtRevision, ref list, initialNode);
}
}
// used for search by filename
IList <DiffInfo> GetFileHistory(NodeAtTime nod, long startRevision, long endRevision, ICollection <long> ignoreRevisions, bool stopOnCopy)
{
IList <DiffInfo> result = new List <DiffInfo>();
if (nod != null)
{
GetFileHistory(nod, startRevision, endRevision, ref result, ignoreRevisions, stopOnCopy);
}
return(result);
}
public DiffInfo GetCreation(NodeAtTime nodeAtTime)
{
if (this.Disposed)
{
Progress.DebugLog("GetCreation called on closed SubversionSearcher");
return(null);
}
if (nodeAtTime.IsFolder)
{
return(null);
}
long revA = 0;
long revC = nodeAtTime.DeleteRevision.HasValue ? nodeAtTime.DeleteRevision.Value - 1 : long.MaxValue;
if (nodeAtTime.Actions.Count > 1)
{
revC = nodeAtTime.Actions[1].Revision - 1;
}
IList <NodeAtTime> li;
if (nodes.TryGetValue(nodeAtTime.Path, out li))
{
for (int i = li.Count - 1; i >= 0; i--)
{
if (li[i] != nodeAtTime)
{
continue;
}
if (i > 0)
{
i--;
if (li[i].DeleteRevision.HasValue)
{
revA = li[i].DeleteRevision.Value;
}
else
{
Progress.DebugLog("DeleteRevision is null for {0}@{1}", li[i].Path, li[i].AddRevision);
}
}
break;
}
}
var newDI = new DiffInfo(nodeAtTime.Path, revA, nodeAtTime.AddRevision, revC);
newDI.SetNodeAtTime(nodeAtTime);
return(newDI);
}
void GetFileHistory(NodeAtTime node, long startRevision, long endRevision, ref IList <DiffInfo> history, ICollection <long> ignoreRevisions, bool stopOnCopy)
{
if (stopOnCopy || node.Ancestor == null)
{
// adding creation as diff
AddDiffsForNode(node, startRevision, endRevision, ref history, ignoreRevisions);
}
else
{
// follow node to creation
AddDiffsForNode(node, startRevision, endRevision, ref history, ignoreRevisions);
GetFileHistory(node.Ancestor.Ancestor, startRevision, node.Ancestor.CopiedAtRevision, ref history, ignoreRevisions, false);
}
}
private int GetNodeChecksum(NodeAtTime node, long revision)
{
int result = 0;
foreach (NodeAtTime n in node.Children)
{
if (n.ExistsAtRevision(revision))
{
result += GetNodeChecksum(n, revision);
}
}
return(result);
}
public IList <MovementInfo> GetMovementInfos(NodeAtTime node)
{
if (this.Disposed)
{
Progress.DebugLog("GetMovementInfos called on closed SubversionSearcher");
return(null);
}
if (node != null)
{
IList <MovementInfo> result = new List <MovementInfo>();
GetMovementInfos(node, HeadRevision, ref result);
return(result);
}
else
{
return(null);
}
}
private void AddModification(string nodePath, long revision, bool removeFromSameAdds = false)
{
NodeAtTime node = GetNodeAtTime(nodePath, revision);
if (node != null)
{
if (removeFromSameAdds)
{
ISet <NodeAtTime> set;
if (equalAdds.TryGetValue(node, out set))
{
set.Remove(node);
equalAdds.Remove(node);
}
}
node.AddModification(revision);
}
else
{
Progress.DebugLog("Did not find {0}@{1} to add modification to it", nodePath, revision);
}
}
public void SetNodeAtTime(NodeAtTime node)
{
this._nodeAtTime = node;
}
void AddDiffsForNode(NodeAtTime node, long startRevision, long endRevision, ref IList <DiffInfo> diffs, ICollection <long> ignoreRevsions)
{
if (node.IsFolder)
{
return;
}
long prevRev = 0;
long nextRev;
// finding delete revision of previous node that existed here
IList <NodeAtTime> li;
if (nodes.TryGetValue(node.Path, out li))
{
for (int j = li.Count - 1; j >= 0; j--)
{
if (li[j] != node)
{
continue;
}
if (j-- > 0)
{
prevRev = li[j].DeleteRevision == null ? long.MaxValue : li[j].DeleteRevision.Value;
}
break;
}
}
for (int i = 0; i < node.Actions.Count; i++)
{
var na = node.Actions[i];
// revision span
if (na.Revision < startRevision)
{
continue;
}
else if (na.Revision > endRevision)
{
break;
}
// ignoring delete revision because we don't diff deletes
if (ignoreRevsions.Contains(na.Revision) || node.DeleteRevision.HasValue && na.Revision == node.DeleteRevision)
{
continue;
}
// finding maximum upper revision
if (i < node.Actions.Count - 1)
{
nextRev = node.Actions[i + 1].Revision - 1;
}
else
{
nextRev = node.DeleteRevision.HasValue ? node.DeleteRevision.Value - 1 : HeadRevision;
}
DiffInfo newDI = null;
if (prevRev != na.Revision)
{
diffs.Add(newDI = new DiffInfo(node.Path, prevRev, na.Revision, nextRev));
}
if (newDI != null)
{
newDI.SetNodeAtTime(node);
}
prevRev = na.Revision;
}
}
// creates a new copy of NodeAtTime in this tree an links them // has to be directory
private NodeAtTime AddCopy(
string path, NodeAtTime previousNode, NodeAtTime parent,
long currentRevision, long previousRevision,
ref ISet <string> filesCopiedThisRevision)
{
NodeAtTime currentNode;
currentNode = new NodeAtTime(path, currentRevision, new AncestorRelation(previousNode, previousRevision));
if (previousNode.IsFolder)
{
currentNode.SetIsFolder(false);
foreach (var c in previousNode.Children)
{
if (c.ExistsAtRevision(previousRevision))
{
string relpath;
if (previousNode.Path == "")
{
relpath = "/" + c.Path;
}
else
{
relpath = c.Path.Substring(previousNode.Path.Length);
}
string newPath = path + relpath;
AddCopy(newPath, c, currentNode, currentRevision, previousRevision, ref filesCopiedThisRevision);
}
}
}
else
{
if (previousNode.IsFile)
{
currentNode.SetIsFile(false);
}
// gets put into this list so it can be deleted from the equalAdds list if it's modified in the same revision it's copied
filesCopiedThisRevision.Add(currentNode.Path);
if (previousNode.Actions.Count == 1 || previousNode.Actions[1].Revision > previousRevision)
{
// if our first content is the same as our parents
ISet <NodeAtTime> eqli;
if (!equalAdds.TryGetValue(previousNode, out eqli))
{
equalAdds[previousNode] = eqli = new HashSet <NodeAtTime>();
eqli.Add(previousNode);
}
equalAdds[currentNode] = eqli;
eqli.Add(currentNode);
}
}
if (parent != null)
{
parent.AddChild(currentNode);
}
IList <NodeAtTime> nodesWithSamePath;
if (!nodes.TryGetValue(currentNode.Path, out nodesWithSamePath))
{
nodes[currentNode.Path] = nodesWithSamePath = new List <NodeAtTime>();
}
nodesWithSamePath.Add(currentNode);
return(currentNode);
}
private void AddAddition(string nodePath, SimplifiedSvnChangeItem changeItem, long revision, ref ISet <string> filesCopiedThisRevision)
{
NodeAtTime parent = null;
// get parent
int t = 0;
for (int k = nodePath.Length - 1; k >= 0; k--)
{
if (nodePath[k] == '/')
{
t = k;
break;
}
}
string parentPath = nodePath.Substring(0, t);
IList <NodeAtTime> parli;
if (nodes.TryGetValue(parentPath, out parli))
{
if (parli.Count > 0)
{
parent = parli[parli.Count - 1];
}
}
else if (!String.IsNullOrEmpty(parentPath))
{
Progress.DebugLog("Could not find Parent \"{0}\"", parentPath);
}
//-------
if (changeItem.CopyFromPath != null)
{
string cpFromPath = changeItem.CopyFromPath.Length > 1 ? changeItem.CopyFromPath.Substring(1) : "";
var previousNode = GetNodeAtTime(cpFromPath, changeItem.CopyFromRevision);
if (previousNode != null)
{
AddCopy(nodePath, previousNode, parent, revision, changeItem.CopyFromRevision, ref filesCopiedThisRevision);
}
else
{
Progress.DebugLog("Ancestor of {0}@{1} not found: {2}@{3}", nodePath, revision, cpFromPath, changeItem.CopyFromRevision);
return;
}
}
else
{
NodeAtTime newlyAdded;
IList <NodeAtTime> nodesWithSamePath;
if (!nodes.TryGetValue(nodePath, out nodesWithSamePath))
{
nodes[nodePath] = nodesWithSamePath = new List <NodeAtTime>();
}
newlyAdded = new NodeAtTime(nodePath, revision);
if (parent != null)
{
parent.AddChild(newlyAdded);
}
if (changeItem.NodeKind == SvnNodeKind.Directory)
{
newlyAdded.SetIsFolder();
}
else if (changeItem.NodeKind == SvnNodeKind.File)
{
newlyAdded.SetIsFile();
}
nodesWithSamePath.Add(newlyAdded);
}
}
public AncestorRelation(NodeAtTime ancestor, long copiedAtRevision)
{
Ancestor = ancestor;
CopiedAtRevision = copiedAtRevision;
}
public void AddChild(NodeAtTime child)
{
Children.Add(child);
SetIsFolder();
}
