private StashedState OnStashSaveCompleted(bool created)
{
if (created)
{
var stashTopData = Repository.Accessor.QueryStashTop.Invoke(
new QueryStashTopParameters(true));
Revision revision;
lock (Repository.Revisions.SyncRoot)
{
revision = ObjectFactories.CreateRevision(Repository, stashTopData);
}
var res = new StashedState(Repository, 0, revision);
lock (SyncRoot)
{
_stash.Insert(0, res);
for (int i = 1; i < _stash.Count; ++i)
{
++_stash[i].Index;
}
InvokeStashedStateCreated(res);
}
Repository.OnCommitCreated(res.Revision);
Repository.Status.Refresh();
return(res);
}
else
{
return(null);
}
}
/// <summary>Update parameter value.</summary>
public void Refresh()
{
if (_configFile == ConfigFile.Repository)
{
Repository.Configuration.Refresh(this);
}
else
{
ConfigParameterData configParameterData;
if (_configFile == ConfigFile.Other)
{
configParameterData = _configAccessor.QueryConfigParameter.Invoke(
new QueryConfigParameterParameters(_fileName, Name));
}
else
{
configParameterData = _configAccessor.QueryConfigParameter.Invoke(
new QueryConfigParameterParameters(_configFile, Name));
}
if (configParameterData == null)
{
MarkAsDeleted();
}
else
{
ObjectFactories.UpdateConfigParameter(this, configParameterData);
}
}
}
public void Refresh()
{
var reflog = Repository.Accessor.QueryReflog.Invoke(
new QueryReflogParameters(Reference.FullName));
lock (SyncRoot)
{
if (reflog.Count < _reflog.Count)
{
for (int i = _reflog.Count - 1; i >= reflog.Count; --i)
{
_reflog[i].MarkAsDeleted();
_reflog.RemoveAt(i);
}
}
for (int i = 0; i < _reflog.Count; ++i)
{
ObjectFactories.UpdateReflogRecord(_reflog[i], reflog[i]);
}
for (int i = _reflog.Count; i < reflog.Count; ++i)
{
var reflogRecord = ObjectFactories.CreateReflogRecord(this, reflog[i]);
_reflog.Add(reflogRecord);
InvokeRecordAdded(reflogRecord);
}
}
}
/// <summary>Returns revision with specified SHA1 or <c>null</c> if such revision does not exist.</summary>
/// <param name="sha1">SHA-1 of required revision.</param>
/// <returns>Revision with specified SHA-1 or <c>null</c> if such revision does not exist.</returns>
/// <remarks>If revision is not present in cache, it will be queried from git repo.</remarks>
public Revision TryGetRevision(Hash sha1)
{
lock (SyncRoot)
{
Revision revision;
if (_revisions.TryGetValue(sha1, out revision))
{
if (!revision.IsLoaded)
{
revision.Load();
}
}
else
{
RevisionData revisionData = null;
try
{
revisionData = Repository.Accessor.QueryRevision.Invoke(
new QueryRevisionParameters(sha1));
}
catch (GitException)
{
return(null);
}
revision = ObjectFactories.CreateRevision(Repository, revisionData);
}
return(revision);
}
}
public void Load()
{
var revisionData = Repository.Accessor.QueryRevision.Invoke(
new QueryRevisionParameters(Hash));
ObjectFactories.UpdateRevision(this, revisionData);
}
/// <summary>
/// Transforms list of <see cref="RevisionData"/> into array of <see cref="Revision"/> objects
/// creating, caching and updating revisions if necessary.
/// </summary>
/// <param name="data">List of <see cref="RevisionData"/> objects.</param>
/// <returns>Array of corresponding <see cref="Revision"/> objects.</returns>
internal Revision[] Resolve(IList <RevisionData> data)
{
Verify.Argument.IsNotNull(data, nameof(data));
var res = new Revision[data.Count];
lock (SyncRoot)
{
for (int i = 0; i < data.Count; ++i)
{
var revisionData = data[i];
Revision revision;
if (_revisions.TryGetValue(revisionData.SHA1, out revision))
{
if (!revision.IsLoaded)
{
ObjectFactories.UpdateRevision(revision, revisionData);
}
}
else
{
revision = ObjectFactories.CreateRevision(Repository, revisionData);
}
res[i] = revision;
}
}
return(res);
}
internal void NotifyRecordAdded()
{
var data = Repository.Accessor.QueryReflog.Invoke(
new QueryReflogParameters(Reference.FullName)
{
MaxCount = 1,
});
if (data.Count != 1)
{
return;
}
var record = data[0];
lock (SyncRoot)
{
if (_reflog.Count != 0)
{
if (record.Revision.SHA1 == _reflog[0].Revision.Hash)
{
return;
}
}
var item = ObjectFactories.CreateReflogRecord(this, record);
_reflog.Insert(0, item);
for (int i = 1; i < _reflog.Count; ++i)
{
_reflog[i].Index = i;
}
InvokeRecordAdded(item);
}
}
/// <summary>Notifies that remote branch was created externally.</summary>
/// <param name="branchData">Created remote branch data.</param>
/// <returns>Created remote branch.</returns>
internal RemoteBranch NotifyCreated(BranchData branchData)
{
var branch = ObjectFactories.CreateRemoteBranch(Repository, branchData);
AddObject(branch);
return(branch);
}
public Task <IList <TreeFile> > GetFilesToAddAsync(string pattern, bool includeUntracked, bool includeIgnored, IProgress <OperationProgress> progress, CancellationToken cancellationToken)
{
if (progress != null)
{
progress.Report(new OperationProgress(Resources.StrLookingForFiles.AddEllipsis()));
}
var parameters = GetAddFilesParameters(pattern, includeUntracked, includeIgnored);
var block = Repository.Monitor.BlockNotifications(RepositoryNotifications.IndexUpdated);
return(Repository.Accessor.QueryFilesToAdd.InvokeAsync(parameters, progress, cancellationToken)
.ContinueWith(
t =>
{
block.Dispose();
var files = TaskUtility.UnwrapResult(t);
var result = new List <TreeFile>(files.Count);
foreach (var treeFileData in files)
{
result.Add(ObjectFactories.CreateTreeFile(Repository, treeFileData));
}
return (IList <TreeFile>)result;
},
CancellationToken.None,
TaskContinuationOptions.ExecuteSynchronously,
TaskScheduler.Default));
}
/// <summary>Notifies that tag was created externally.</summary>
/// <param name="tagData">Created tag data.</param>
/// <returns>Created tag.</returns>
internal Tag NotifyCreated(TagData tagData)
{
var tag = ObjectFactories.CreateTag(Repository, tagData);
AddObject(tag);
return(tag);
}
/// <summary>Synchronize cached information with actual data.</summary>
public void Refresh()
{
IList <ConfigParameterData> config;
switch (_configFile)
{
case ConfigFile.Other:
config = _configAccessor.QueryConfig.Invoke(
new QueryConfigParameters(_fileName));
break;
case ConfigFile.Repository:
config = _configAccessor.QueryConfig.Invoke(
new QueryConfigParameters());
break;
case ConfigFile.System:
case ConfigFile.User:
config = _configAccessor.QueryConfig.Invoke(
new QueryConfigParameters(_configFile));
break;
default:
throw new ApplicationException(
string.Format(CultureInfo.InvariantCulture, "Unknown ConfigFile value: {0}", _configFile));
}
lock (SyncRoot)
{
if (_repository != null)
{
CacheUpdater.UpdateObjectDictionary(
_parameters,
null,
null,
config,
configParameterData => ObjectFactories.CreateConfigParameter(_repository, configParameterData),
ObjectFactories.UpdateConfigParameter,
InvokeCreated,
InvokeDeleted,
true);
}
else
{
CacheUpdater.UpdateObjectDictionary(
_parameters,
null,
null,
config,
configParameterData => ObjectFactories.CreateConfigParameter(_configAccessor, configParameterData),
ObjectFactories.UpdateConfigParameter,
InvokeCreated,
InvokeDeleted,
true);
}
}
}
/// <summary>
/// Evaluate commit which is targeted by this <see cref="IRevisionPointer"/>.
/// </summary>
/// <returns>
/// Commit which is pointed by this <see cref="IRevisionPointer"/>.
/// </returns>
public Revision Dereference()
{
var revisionData = _reference.Repository.Accessor.Dereference.Invoke(
new DereferenceParameters(FullName)
{
LoadRevisionData = true,
});
return(ObjectFactories.CreateRevision(_reference.Repository, revisionData));
}
/// <summary>Perform initial load of tags.</summary>
/// <param name="tagDataList">List of tag data containers.</param>
internal void Load(IEnumerable <TagData> tagDataList)
{
ObjectStorage.Clear();
if (tagDataList != null)
{
foreach (var tagData in tagDataList)
{
AddObject(ObjectFactories.CreateTag(Repository, tagData));
}
}
}
/// <summary>Perform initial load of remote branches.</summary>
/// <param name="branchDataList">List of remote branch data containers.</param>
internal void Load(IEnumerable <BranchData> branchDataList)
{
ObjectStorage.Clear();
if (branchDataList != null)
{
foreach (var remoteBranchData in branchDataList)
{
AddObject(ObjectFactories.CreateRemoteBranch(Repository, remoteBranchData));
}
}
}
private void RefreshInternal(IEnumerable <TagData> tagDataList)
{
lock (SyncRoot)
{
CacheUpdater.UpdateObjectDictionary(
ObjectStorage,
null,
null,
tagDataList,
tagData => ObjectFactories.CreateTag(Repository, tagData),
ObjectFactories.UpdateTag,
InvokeObjectAdded,
InvokeObjectRemoved,
true);
}
}
/// <summary>Updates remote branch cache.</summary>
/// <param name="branches">Actual remote branch data.</param>
private void RefreshInternal(IEnumerable <BranchData> branches)
{
lock (SyncRoot)
{
CacheUpdater.UpdateObjectDictionary <RemoteBranch, BranchData>(
ObjectStorage,
null,
branchData => branchData.IsRemote,
branches,
remoteBranchData => ObjectFactories.CreateRemoteBranch(Repository, remoteBranchData),
ObjectFactories.UpdateRemoteBranch,
InvokeObjectAdded,
InvokeObjectRemoved,
true);
}
}
/// <summary>Refresh tag's position (remove tag if it doesn't exist anymore and recreate if position differs).</summary>
/// <param name="tag">Tag to refresh.</param>
internal void Refresh(Tag tag)
{
Verify.Argument.IsValidGitObject(tag, Repository, "tag");
var tagData = Repository.Accessor.QueryTag.Invoke(
new QueryTagParameters(tag.Name));
if (tagData != null)
{
ObjectFactories.UpdateTag(tag, tagData);
}
else
{
RemoveObject(tag);
}
}
/// <summary>Refresh branch's position (and remove branch if it doesn't exist anymore).</summary>
/// <param name="branch">Branch to refresh.</param>
internal void Refresh(RemoteBranch branch)
{
Verify.Argument.IsValidGitObject(branch, Repository, "branch");
var remoteBranchData = Repository.Accessor.QueryBranch.Invoke(
new QueryBranchParameters(branch.Name, branch.IsRemote));
if (remoteBranchData != null)
{
ObjectFactories.UpdateRemoteBranch(branch, remoteBranchData);
}
else
{
RemoveObject(branch);
}
}
public void Refresh()
{
var config = Repository.Accessor.QueryConfig.Invoke(
new QueryConfigParameters());
lock (SyncRoot)
{
CacheUpdater.UpdateObjectDictionary <ConfigParameter, ConfigParameterData>(
_parameters,
null,
null,
config,
configParameterData => ObjectFactories.CreateConfigParameter(Repository, configParameterData),
ObjectFactories.UpdateConfigParameter,
InvokeParameterCreated,
InvokeParameterDeleted,
true);
}
}
public void Refresh()
{
var users = Repository.Accessor.QueryUsers.Invoke(
new QueryUsersParameters());
lock (SyncRoot)
{
CacheUpdater.UpdateObjectDictionary <User, UserData>(
ObjectStorage,
null,
null,
users,
userData => ObjectFactories.CreateUser(Repository, userData),
ObjectFactories.UpdateUser,
InvokeObjectAdded,
InvokeObjectRemoved,
true);
}
}
/// <summary>Sync information on remotes: removes non-existent, adds new, updates url.</summary>
public void Refresh()
{
var remotes = Repository.Accessor.QueryRemotes.Invoke(
new QueryRemotesParameters());
lock (SyncRoot)
{
CacheUpdater.UpdateObjectDictionary <Remote, RemoteData>(
ObjectStorage,
null,
null,
remotes,
remoteData => ObjectFactories.CreateRemote(Repository, remoteData),
ObjectFactories.UpdateRemote,
InvokeObjectAdded,
InvokeObjectRemoved,
true);
}
}
public async Task <IList <TreeFile> > GetFilesToAddAsync(string pattern, bool includeUntracked, bool includeIgnored, IProgress <OperationProgress> progress, CancellationToken cancellationToken)
{
progress?.Report(new OperationProgress(Resources.StrLookingForFiles.AddEllipsis()));
var parameters = GetAddFilesParameters(pattern, includeUntracked, includeIgnored);
var block = Repository.Monitor.BlockNotifications(RepositoryNotifications.IndexUpdated);
var files = await Repository
.Accessor
.QueryFilesToAdd
.InvokeAsync(parameters, progress, cancellationToken);
block.Dispose();
var result = new List <TreeFile>(files.Count);
foreach (var treeFileData in files)
{
result.Add(ObjectFactories.CreateTreeFile(Repository, treeFileData));
}
return(result);
}
public void Refresh()
{
var notes = Repository.Accessor.QueryNotes.Invoke(
new QueryNotesParameters());
lock (SyncRoot)
{
CacheUpdater.UpdateObjectDictionary <Note, NoteData>(
_notes,
null,
null,
notes,
noteData => ObjectFactories.CreateNote(Repository, noteData),
ObjectFactories.UpdateNode,
InvokeCreated,
InvokeDeleted,
true);
}
}
public static TreeDirectory CreateTreeDirectory(Repository repository, TreeDirectoryData treeDirectoryData)
{
Verify.Argument.IsNotNull(repository, "repository");
Verify.Argument.IsNotNull(treeDirectoryData, "treeDirectoryData");
var directory = new TreeDirectory(repository, treeDirectoryData.Name, null, treeDirectoryData.ShortName)
{
StagedStatus = treeDirectoryData.StagedStatus,
};
foreach (var subDirectory in treeDirectoryData.Directories)
{
directory.AddDirectory(CreateTreeDirectory(repository, subDirectory));
}
foreach (var file in treeDirectoryData.Files)
{
directory.AddFile(ObjectFactories.CreateTreeFile(repository, file));
}
return(directory);
}
private bool Merge(
IDictionary <string, TreeFile> oldPlainList, TreeDirectory oldRoot,
IDictionary <string, TreeFileData> newPlainList, TreeDirectoryData newRoot)
{
bool res = false;
var removeList = new List <string>();
foreach (var oldFileKvp in oldPlainList)
{
TreeFileData file;
if (newPlainList.TryGetValue(oldFileKvp.Key, out file))
{
newPlainList.Remove(oldFileKvp.Key);
ObjectFactories.UpdateTreeFile(oldFileKvp.Value, file);
}
else
{
removeList.Add(oldFileKvp.Key);
res = true;
}
}
foreach (var s in removeList)
{
oldPlainList.Remove(s);
}
if (newPlainList.Count != 0)
{
res = true;
foreach (var newFileKvp in newPlainList)
{
oldPlainList.Add(newFileKvp.Key, ObjectFactories.CreateTreeFile(Repository, newFileKvp.Value));
}
}
Update(newRoot, oldRoot);
return(res);
}
/// <summary>Returns revision with specified SHA1.</summary>
/// <param name="sha1">SHA-1 of required revision.</param>
/// <returns>Revision with specified SHA-1.</returns>
/// <exception cref="ArgumentException">Invalid SHA-1 expression.</exception>
/// <exception cref="GitException">Revision does not exist.</exception>
/// <remarks>If revision is not present in cache, it will be queried from git repo.</remarks>
public Revision this[Hash sha1]
{
get
{
lock (SyncRoot)
{
Revision revision;
if (_revisions.TryGetValue(sha1, out revision))
{
if (!revision.IsLoaded)
{
revision.Load();
}
}
else
{
var revisionData = Repository.Accessor.QueryRevision.Invoke(
new QueryRevisionParameters(sha1));
revision = ObjectFactories.CreateRevision(Repository, revisionData);
}
return(revision);
}
}
}
internal void Refresh(ConfigParameter configParameter)
{
Verify.Argument.IsNotNull(configParameter, "configParameter");
string name = configParameter.Name;
var configParameterData = Repository.Accessor.QueryConfigParameter.Invoke(
new QueryConfigParameterParameters(configParameter.Name));
if (configParameterData == null)
{
lock (SyncRoot)
{
_parameters.Remove(name.ToLowerInvariant());
InvokeParameterDeleted(configParameter);
}
}
else
{
lock (SyncRoot)
{
ObjectFactories.UpdateConfigParameter(configParameter, configParameterData);
}
}
}
/// <summary>Refresh stash content.</summary>
public void Refresh()
{
var top = Repository.Accessor.QueryStashTop.Invoke(
new QueryStashTopParameters(false));
var stash = (top == null)?
new StashedStateData[0] :
Repository.Accessor.QueryStash.Invoke(new QueryStashParameters());
lock (SyncRoot)
lock (Repository.Revisions.SyncRoot)
{
if (_stash.Count != 0)
{
if (stash.Count == 0)
{
for (int i = _stash.Count - 1; i >= 0; --i)
{
var s = _stash[i];
_stash.RemoveAt(i);
InvokeStashedStateDeleted(s);
}
}
else
{
var d = new Dictionary <Hash, StashedState>(_stash.Count, Hash.EqualityComparer);
foreach (var s in _stash)
{
d.Add(s.Revision.Hash, s);
}
_stash.Clear();
foreach (var ssinfo in stash)
{
StashedState stashedState;
if (!d.TryGetValue(ssinfo.Revision.SHA1, out stashedState))
{
stashedState = ObjectFactories.CreateStashedState(Repository, ssinfo);
_stash.Add(stashedState);
InvokeStashedStateCreated(stashedState);
}
else
{
ObjectFactories.UpdateStashedState(stashedState, ssinfo);
d.Remove(ssinfo.Revision.SHA1);
_stash.Add(stashedState);
}
}
if (d.Count != 0)
{
foreach (var ss in d.Values)
{
InvokeStashedStateDeleted(ss);
}
}
}
}
else
{
if (stash.Count != 0)
{
foreach (var stashedStateData in stash)
{
var stashedState = ObjectFactories.CreateStashedState(Repository, stashedStateData);
_stash.Add(stashedState);
InvokeStashedStateCreated(stashedState);
}
}
}
}
}
public void Refresh()
{
var submodules = new Dictionary <string, SubmoduleData>();
var cfg = Path.Combine(Repository.WorkingDirectory, GitConstants.SubmodulesConfigFile);
bool skipUpdate = false;
if (File.Exists(cfg))
{
ConfigurationFile cfgFile = null;
try
{
cfgFile = new ConfigurationFile(Repository, GitConstants.SubmodulesConfigFile, true);
}
catch (Exception exc) when(!exc.IsCritical())
{
skipUpdate = true;
}
if (cfgFile != null)
{
foreach (var param in cfgFile)
{
if (param.Name.StartsWith("submodule."))
{
int p = param.Name.LastIndexOf('.', param.Name.Length - 1, param.Name.Length - "submodule.".Length);
if (p != -1 && p != param.Name.Length - 1)
{
var p3 = param.Name.Substring(p + 1);
bool valueIsPath = false;
bool valueIsUrl = false;
switch (p3)
{
case "path":
valueIsPath = true;
break;
case "url":
valueIsUrl = true;
break;
default:
continue;
}
var name = param.Name.Substring("submodule.".Length, p - "submodule.".Length);
SubmoduleData info;
if (!submodules.TryGetValue(name, out info))
{
info = new SubmoduleData(name);
submodules.Add(name, info);
}
if (valueIsPath)
{
info.Path = param.Value;
}
if (valueIsUrl)
{
info.Url = param.Value;
}
}
}
}
}
}
if (!skipUpdate)
{
lock (SyncRoot)
{
CacheUpdater.UpdateObjectDictionary <Submodule, SubmoduleData>(
ObjectStorage,
null,
null,
submodules,
submoduleData => ObjectFactories.CreateSubmodue(Repository, submoduleData),
ObjectFactories.UpdateSubmodule,
InvokeObjectAdded,
InvokeObjectRemoved,
true);
}
}
}
private void Update(TreeDirectoryData sourceDirectory, TreeDirectory targetDirectory)
{
bool[] existance;
bool[] matched;
#region update subdirectories
existance = new bool[targetDirectory.Directories.Count];
matched = new bool[sourceDirectory.Directories.Count];
for (int i = 0; i < targetDirectory.Directories.Count; ++i)
{
var targetSubDirectory = targetDirectory.Directories[i];
for (int j = 0; j < sourceDirectory.Directories.Count; ++j)
{
if (!matched[j])
{
var sourceSubDirectory = sourceDirectory.Directories[j];
if (targetSubDirectory.Name == sourceSubDirectory.ShortName)
{
existance[i] = true;
matched[j] = true;
Update(sourceSubDirectory, targetSubDirectory);
break;
}
}
}
}
for (int i = targetDirectory.Directories.Count - 1; i >= 0; --i)
{
if (!existance[i])
{
var directory = targetDirectory.Directories[i];
targetDirectory.RemoveDirectoryAt(i);
InvokeRemovedDirectory(directory);
}
}
for (int i = 0; i < sourceDirectory.Directories.Count; ++i)
{
if (!matched[i])
{
var directory = ObjectFactories.CreateTreeDirectory(Repository, sourceDirectory.Directories[i]);
targetDirectory.AddDirectory(directory);
InvokeAddedDirectory(directory);
}
}
#endregion
#region update files
existance = new bool[targetDirectory.Files.Count];
matched = new bool[sourceDirectory.Files.Count];
for (int i = 0; i < targetDirectory.Files.Count; ++i)
{
var targetFile = targetDirectory.Files[i];
for (int j = 0; j < sourceDirectory.Files.Count; ++j)
{
if (!matched[j])
{
var sourceFile = sourceDirectory.Files[j];
if (targetFile.Name == sourceFile.ShortName)
{
existance[i] = true;
matched[j] = true;
targetFile.Status = sourceFile.FileStatus;
break;
}
}
}
}
for (int i = targetDirectory.Files.Count - 1; i >= 0; --i)
{
if (!existance[i])
{
var file = targetDirectory.Files[i];
targetDirectory.RemoveFileAt(i);
InvokeRemovedFile(file);
}
}
for (int i = 0; i < sourceDirectory.Files.Count; ++i)
{
if (!matched[i])
{
var treeFile = ObjectFactories.CreateTreeFile(Repository, sourceDirectory.Files[i]);
targetDirectory.AddFile(treeFile);
InvokeNewFile(treeFile);
}
}
#endregion
}
