internal void PrescanOneTree()
{
var visitor = new AbstractIndexTreeVisitor
{
VisitEntry = (m, i, f) =>
{
if (m != null)
{
if (!f.IsFile())
{
CheckConflictsWithFile(f);
}
}
else
{
if (f.Exists)
{
Removed.Add(i.Name);
Conflicts.Remove(i.Name);
}
}
}
};
new IndexTreeWalker(_index, _merge, _root, visitor).Walk();
Conflicts.RemoveAll(conflict => Removed.Contains(conflict));
}
internal void PrescanTwoTrees()
{
var visitor = new AbstractIndexTreeVisitor
{
VisitEntryAux = (treeEntry, auxEntry, indexEntry, file) =>
{
if (treeEntry is Tree || auxEntry is Tree)
{
throw new ArgumentException("Can't pass me a tree!");
}
ProcessEntry(treeEntry, auxEntry, indexEntry);
},
FinishVisitTree = (tree, auxTree, currentDirectory) =>
{
if (currentDirectory.Length == 0)
{
return;
}
if (auxTree == null)
{
return;
}
if (_index.GetEntry(currentDirectory) != null)
{
Removed.Add(currentDirectory);
}
}
};
new IndexTreeWalker(_index, _head, _merge, _root, visitor).Walk();
// if there's a conflict, don't list it under
// to-be-removed, since that messed up our next
// section
Removed.RemoveAll(removed => Conflicts.Contains(removed));
foreach (string path in _updated.Keys)
{
if (_index.GetEntry(path) == null)
{
FileSystemInfo file = new FileInfo(Path.Combine(_root.DirectoryName(), path));
if (file.IsFile())
{
Conflicts.Add(path);
}
else if (file.IsDirectory())
{
CheckConflictsWithFile(file);
}
}
}
Conflicts.RemoveAll(conflict => Removed.Contains(conflict));
}
/// <summary>
/// Run the diff operation. Until this is called, all lists will be empty
/// </summary>
/// <returns>true if anything is different between index, tree, and workdir</returns>
public bool Diff()
{
DirectoryInfo root = _index.Repository.WorkingDirectory;
var visitor = new AbstractIndexTreeVisitor
{
VisitEntry = delegate(TreeEntry treeEntry, GitIndex.Entry indexEntry, FileInfo file)
{
if (treeEntry == null)
{
Added.Add(indexEntry.Name);
_anyChanges = true;
}
else if (indexEntry == null)
{
if (!(treeEntry is Tree))
{
Removed.Add(treeEntry.FullName);
}
_anyChanges = true;
}
else
{
if (!treeEntry.Id.Equals(indexEntry.ObjectId))
{
Changed.Add(indexEntry.Name);
_anyChanges = true;
}
}
if (indexEntry != null)
{
if (!file.Exists)
{
Missing.Add(indexEntry.Name);
_anyChanges = true;
}
else
{
if (indexEntry.IsModified(root, true))
{
Modified.Add(indexEntry.Name);
_anyChanges = true;
}
}
}
}
};
new IndexTreeWalker(_index, _tree, root, visitor).Walk();
CheckUntrackedDirectory(root.FullName, "");
return(_anyChanges);
}
public void Remove <T>(T entity) where T : class
{
//if (typeof(T) == typeof(Log))
//{
// LogRemoved.Add(entity);
//}
//else
//{
Removed.Add(entity);
//}
}
private void RemoveItemAt(int index)
{
var container = Items[index];
Items.RemoveAt(index);
// If the item being removed was added, that means we don't need to track it
// anymore, so the below does not apply.
if (container.Action != ChangeAction.Add)
{
container.Action = ChangeAction.Remove;
Removed.Add(container);
}
}
private PathStatus OnRemoved(string path, PathStatus status)
{
if (Options.PerPathNotificationCallback != null)
{
if (status == null)
{
status = new PathStatus(Repository, path);
}
status.IndexPathStatus = IndexPathStatus.Removed;
}
Removed.Add(path);
AnyDifferences = true;
return(status);
}
//public void RegisterClean(TModel e)
//{
// Dirty.Remove(e);
//}
public TModel RegisterRemoved(TModel e)
{
if (New.Remove(e))
{
return(e);
}
Dirty.Remove(e);
if (!Removed.Contains(e))
{
Removed.Add(e);
}
return(e);
}
public override void Update(float elapsed)
{
foreach (IController controller in Controllers)
{
controller.UpdateSystemCommands(elapsed);
}
if (!isPaused)
{
if (Scene.mario.CurrentPowerState is MarioDeadState)
{
Scene.mario.Update(elapsed);
}
else
{
hud.Update(elapsed);
foreach (IController controller in Controllers)
{
controller.UpdatePlayerCommands(elapsed);
}
SpatialGrid collisionGrid = new SpatialGrid(Scene.Bound);
foreach (Entity entity in Entities)
{
if (entity.Removed)
{
Removed.Add(entity);
}
else
{
entity.Update(elapsed);
if (entity.Collidable)
{
collisionGrid.Add(entity);
}
}
}
scene.RemoveEntities();
scene.UpdateCamera();
collisionGrid.CheckCollisions();
}
}
}
private async Task RemoveMissingFilesAsync(IDbConnection connection, Stopwatch stopwatch, IProgress <SyncProgress> progress)
{
progress?.Report(new SyncProgress()
{
Message = "Removing deleted files...", Elapsed = stopwatch.Elapsed
});
var allFiles = await GetAllFilesAsync(connection);
string rootPath = GetRootPath(connection);
foreach (var file in allFiles)
{
if (!System.IO.File.Exists(Path.Combine(rootPath, file.Path)))
{
Removed.Add(file);
progress?.Report(new SyncProgress()
{
Message = $"Removing {file.Path}", Elapsed = stopwatch.Elapsed
});
await RemoveFileAsync(connection, file);
}
}
}
public override EntityEntry <T> Remove(T entity)
{
Removed.Add(entity);
return(null);
}
public void Remove(IDataRecord item)
{
Repository.Signal <IDataRecordRemoving>(_ => _.RecordRemoving(item));
Removed.Add(item.Identifier);
Repository.Signal <IDataRecordRemoved>(_ => _.RecordRemoved(item));
}
private void ProcessEntry(TreeEntry h, TreeEntry m, GitIndex.Entry i)
{
ObjectId iId = (i == null ? null : i.ObjectId);
ObjectId mId = (m == null ? null : m.Id);
ObjectId hId = (h == null ? null : h.Id);
string name = (i != null ? i.Name : (h != null ? h.FullName : m.FullName));
if (i == null)
{
//
// I (index) H M Result
// -------------------------------------------------------
// 0 nothing nothing nothing (does not happen)
// 1 nothing nothing exists use M
// 2 nothing exists nothing remove path from index
// 3 nothing exists exists use M
if (h == null)
{
_updated.Add(name, mId);
}
else if (m == null)
{
Removed.Add(name);
}
else
{
_updated.Add(name, mId);
}
}
else if (h == null)
{
//
// clean I==H I==M H M Result
// -----------------------------------------------------
// 4 yes N/A N/A nothing nothing keep index
// 5 no N/A N/A nothing nothing keep index
//
// 6 yes N/A yes nothing exists keep index
// 7 no N/A yes nothing exists keep index
// 8 yes N/A no nothing exists fail
// 9 no N/A no nothing exists fail
if (m == null || mId.Equals(iId))
{
if (HasParentBlob(_merge, name))
{
if (i.IsModified(_root, true))
{
Conflicts.Add(name);
}
else
{
Removed.Add(name);
}
}
}
else
{
Conflicts.Add(name);
}
}
else if (m == null)
{
//
// 10 yes yes N/A exists nothing remove path from index
// 11 no yes N/A exists nothing fail
// 12 yes no N/A exists nothing fail
// 13 no no N/A exists nothing fail
//
if (hId.Equals(iId))
{
if (i.IsModified(_root, true))
{
Conflicts.Add(name);
}
else
{
Removed.Add(name);
}
}
else
{
Conflicts.Add(name);
}
}
else
{
if (!hId.Equals(mId) && !hId.Equals(iId) && !mId.Equals(iId))
{
Conflicts.Add(name);
}
else if (hId.Equals(iId) && !mId.Equals(iId))
{
if (i.IsModified(_root, true))
{
Conflicts.Add(name);
}
else
{
_updated.Add(name, mId);
}
}
}
}
void IOdeToFoodDb.Remove <T>(T entity)
{
Removed.Add(entity);
}
public void Remove <T>(T entity) where T : class
{
Removed.Add(entity);
}
/// 由于不需要 Note 来支持回滚，这里只保留最新的改变即可。
internal void LogRemove(K key)
{
Removed.Add(key);
Replaced.Remove(key);
}
/// <summary>
/// Run the diff operation. Until this is called, all lists will be empty
/// </summary>
/// <returns>true if anything is different between index, tree, and workdir</returns>
private void UpdateDirectory(IEnumerable <string> paths, bool recursive)
{
RevWalk rw = new RevWalk(Repository);
ObjectId id = Repository.Resolve(Constants.HEAD);
var commit = id != null?rw.ParseCommit(id) : null;
TreeWalk treeWalk = new TreeWalk(Repository);
treeWalk.Reset();
treeWalk.Recursive = false;
if (commit != null)
{
treeWalk.AddTree(commit.Tree);
}
else
{
treeWalk.AddTree(new EmptyTreeIterator());
}
DirCache dc = Repository.ReadDirCache();
treeWalk.AddTree(new DirCacheIterator(dc));
FileTreeIterator workTree = new FileTreeIterator(Repository.WorkTree, Repository.FileSystem, WorkingTreeOptions.KEY.Parse(Repository.GetConfig()));
treeWalk.AddTree(workTree);
List <TreeFilter> filters = new List <TreeFilter> ();
filters.Add(new SkipWorkTreeFilter(1));
var pathFilters = paths.Where(p => p != ".").Select(p => PathFilter.Create(p)).ToArray();
if (pathFilters.Length > 1)
{
filters.Add(OrTreeFilter.Create(pathFilters)); // Use an OR to join all path filters
}
else if (pathFilters.Length == 1)
{
filters.Add(pathFilters[0]);
}
if (filters.Count > 1)
{
treeWalk.Filter = AndTreeFilter.Create(filters);
}
else
{
treeWalk.Filter = filters[0];
}
while (treeWalk.Next())
{
AbstractTreeIterator treeIterator = treeWalk.GetTree <AbstractTreeIterator>(0);
DirCacheIterator dirCacheIterator = treeWalk.GetTree <DirCacheIterator>(1);
WorkingTreeIterator workingTreeIterator = treeWalk.GetTree <WorkingTreeIterator>(2);
NGit.FileMode fileModeTree = treeWalk.GetFileMode(0);
if (treeWalk.IsSubtree)
{
treeWalk.EnterSubtree();
continue;
}
int stage = dirCacheIterator != null?dirCacheIterator.GetDirCacheEntry().Stage : 0;
if (stage > 1)
{
continue;
}
else if (stage == 1)
{
MergeConflict.Add(dirCacheIterator.EntryPathString);
changesExist = true;
continue;
}
if (treeIterator != null)
{
if (dirCacheIterator != null)
{
if (!treeIterator.EntryObjectId.Equals(dirCacheIterator.EntryObjectId))
{
// in repo, in index, content diff => changed
Modified.Add(dirCacheIterator.EntryPathString);
changesExist = true;
}
}
else
{
// in repo, not in index => removed
if (!fileModeTree.Equals(NGit.FileMode.TYPE_TREE))
{
Removed.Add(treeIterator.EntryPathString);
changesExist = true;
}
}
}
else
{
if (dirCacheIterator != null)
{
// not in repo, in index => added
Added.Add(dirCacheIterator.EntryPathString);
changesExist = true;
}
else
{
// not in repo, not in index => untracked
if (workingTreeIterator != null && !workingTreeIterator.IsEntryIgnored())
{
Untracked.Add(workingTreeIterator.EntryPathString);
changesExist = true;
}
}
}
if (dirCacheIterator != null)
{
if (workingTreeIterator == null)
{
// in index, not in workdir => missing
Missing.Add(dirCacheIterator.EntryPathString);
changesExist = true;
}
else
{
// Workaround to file time resolution issues
long itime = dirCacheIterator.GetDirCacheEntry().LastModified;
long ftime = workingTreeIterator.GetEntryLastModified();
if (itime / 1000 != ftime / 1000)
{
if (!dirCacheIterator.IdEqual(workingTreeIterator))
{
// in index, in workdir, content differs => modified
Modified.Add(dirCacheIterator.EntryPathString);
changesExist = true;
}
}
}
}
}
}
public void Remove(object content)
{
Removed.Add(content.ToString());
}