internal static unsafe IndexNameEntry BuildFromPtr(git_index_name_entry *entry)
{
if (entry == null)
{
return(null);
}
string ancestor = entry->ancestor != null
? LaxFilePathMarshaler.FromNative(entry->ancestor).Native
: null;
string ours = entry->ours != null
? LaxFilePathMarshaler.FromNative(entry->ours).Native
: null;
string theirs = entry->theirs != null
? LaxFilePathMarshaler.FromNative(entry->theirs).Native
: null;
return(new IndexNameEntry
{
Ancestor = ancestor,
Ours = ours,
Theirs = theirs,
});
}
/// <summary>
/// Take an unmanaged pointer and convert it to filter source callback paramater
/// </summary>
/// <param name="ptr"></param>
/// <returns></returns>
internal static unsafe FilterSource FromNativePtr(git_filter_source *ptr)
{
FilePath path = LaxFilePathMarshaler.FromNative(ptr->path) ?? FilePath.Empty;
FilterMode gitFilterSourceMode = Proxy.git_filter_source_mode(ptr);
return(new FilterSource(path, gitFilterSourceMode, ptr));
}
private void AddFileChange(GitDiffDelta delta)
{
var pathPtr = delta.NewFile.Path != IntPtr.Zero ? delta.NewFile.Path : delta.OldFile.Path;
var newFilePath = LaxFilePathMarshaler.FromNative(pathPtr);
changes.Add(newFilePath, new ContentChanges(delta.IsBinary()));
}
internal static IndexNameEntry BuildFromPtr(IndexNameEntrySafeHandle handle)
{
if (handle == null || handle.IsZero)
{
return(null);
}
GitIndexNameEntry entry = handle.MarshalAsGitIndexNameEntry();
string ancestor = entry.Ancestor != IntPtr.Zero
? LaxFilePathMarshaler.FromNative(entry.Ancestor).Native
: null;
string ours = entry.Ours != IntPtr.Zero
? LaxFilePathMarshaler.FromNative(entry.Ours).Native
: null;
string theirs = entry.Theirs != IntPtr.Zero
? LaxFilePathMarshaler.FromNative(entry.Theirs).Native
: null;
return(new IndexNameEntry
{
Ancestor = ancestor,
Ours = ours,
Theirs = theirs,
});
}
/// <summary>
/// Take an unmanaged pointer and convert it to filter source callback paramater
/// </summary>
/// <param name="ptr"></param>
/// <returns></returns>
internal static FilterSource FromNativePtr(IntPtr ptr)
{
var source = ptr.MarshalAs <GitFilterSource>();
FilePath path = LaxFilePathMarshaler.FromNative(source.path) ?? FilePath.Empty;
FilterMode gitFilterSourceMode = Proxy.git_filter_source_mode(ptr);
return(new FilterSource(path, gitFilterSourceMode, source));
}
/// <summary>
/// The delegate with a signature that matches the native checkout progress_cb function's signature.
/// </summary>
/// <param name="str">The path that was updated.</param>
/// <param name="completedSteps">The number of completed steps.</param>
/// <param name="totalSteps">The total number of steps.</param>
/// <param name="payload">Payload object.</param>
private void OnGitCheckoutProgress(IntPtr str, UIntPtr completedSteps, UIntPtr totalSteps, IntPtr payload)
{
if (onCheckoutProgress != null)
{
// Convert null strings into empty strings.
FilePath path = LaxFilePathMarshaler.FromNative(str) ?? FilePath.Empty;
onCheckoutProgress(path.Native, (int)completedSteps, (int)totalSteps);
}
}
/// <summary>
/// The delegate with a signature that matches the native diff git_diff_notify_cb function's signature.
/// </summary>
/// <param name="diffListSoFar">The diff list so far, before the delta is inserted.</param>
/// <param name="deltaToAdd">The delta that is being diffed</param>
/// <param name="matchedPathspec">The pathsec that matched the path of the diffed files.</param>
/// <param name="payload">Payload object.</param>
internal int OnGitDiffNotify(IntPtr diffListSoFar, IntPtr deltaToAdd, IntPtr matchedPathspec, IntPtr payload)
{
// Convert null strings into empty strings.
var path = LaxFilePathMarshaler.FromNative(matchedPathspec) ?? FilePath.Empty;
if (matchedPaths.Contains(path))
{
return(0);
}
matchedPaths.Add(path);
return(0);
}
internal TreeEntryChanges(GitDiffDelta delta)
{
Path = LaxFilePathMarshaler.FromNative(delta.NewFile.Path).Native;
OldPath = LaxFilePathMarshaler.FromNative(delta.OldFile.Path).Native;
Mode = (Mode)delta.NewFile.Mode;
OldMode = (Mode)delta.OldFile.Mode;
Oid = delta.NewFile.Id;
OldOid = delta.OldFile.Id;
Status = (delta.Status == ChangeKind.Untracked || delta.Status == ChangeKind.Ignored)
? ChangeKind.Added
: delta.Status;
}
internal unsafe TreeEntryChanges(git_diff_delta *delta)
{
Path = LaxFilePathMarshaler.FromNative(delta->new_file.Path).Native;
OldPath = LaxFilePathMarshaler.FromNative(delta->old_file.Path).Native;
Mode = (Mode)delta->new_file.Mode;
OldMode = (Mode)delta->old_file.Mode;
Oid = ObjectId.BuildFromPtr(&delta->new_file.Id);
OldOid = ObjectId.BuildFromPtr(&delta->old_file.Id);
Exists = (delta->new_file.Flags & GitDiffFlags.GIT_DIFF_FLAG_EXISTS) != 0;
OldExists = (delta->old_file.Flags & GitDiffFlags.GIT_DIFF_FLAG_EXISTS) != 0;
Status = GetStatusFromChangeKind(delta->status);
}
internal TreeEntryChanges(GitDiffDelta delta)
{
Path = LaxFilePathMarshaler.FromNative(delta.NewFile.Path).Native;
OldPath = LaxFilePathMarshaler.FromNative(delta.OldFile.Path).Native;
Mode = (Mode)delta.NewFile.Mode;
OldMode = (Mode)delta.OldFile.Mode;
Oid = delta.NewFile.Id;
OldOid = delta.OldFile.Id;
Exists = (delta.NewFile.Flags & GitDiffFlags.GIT_DIFF_FLAG_EXISTS) != 0;
OldExists = (delta.OldFile.Flags & GitDiffFlags.GIT_DIFF_FLAG_EXISTS) != 0;
Status = (delta.Status == ChangeKind.Untracked || delta.Status == ChangeKind.Ignored)
? ChangeKind.Added
: delta.Status;
}
private unsafe void AddStatusEntryForDelta(FileStatus gitStatus, git_diff_delta *deltaHeadToIndex, git_diff_delta *deltaIndexToWorkDir)
{
RenameDetails headToIndexRenameDetails = null;
RenameDetails indexToWorkDirRenameDetails = null;
if ((gitStatus & FileStatus.RenamedInIndex) == FileStatus.RenamedInIndex)
{
headToIndexRenameDetails =
new RenameDetails(LaxFilePathMarshaler.FromNative(deltaHeadToIndex->old_file.Path).Native,
LaxFilePathMarshaler.FromNative(deltaHeadToIndex->new_file.Path).Native,
(int)deltaHeadToIndex->similarity);
}
if ((gitStatus & FileStatus.RenamedInWorkdir) == FileStatus.RenamedInWorkdir)
{
indexToWorkDirRenameDetails =
new RenameDetails(LaxFilePathMarshaler.FromNative(deltaIndexToWorkDir->old_file.Path).Native,
LaxFilePathMarshaler.FromNative(deltaIndexToWorkDir->new_file.Path).Native,
(int)deltaIndexToWorkDir->similarity);
}
var filePath = (deltaIndexToWorkDir != null)
? LaxFilePathMarshaler.FromNative(deltaIndexToWorkDir->new_file.Path)
: LaxFilePathMarshaler.FromNative(deltaHeadToIndex->new_file.Path);
StatusEntry statusEntry = new StatusEntry(filePath.Native, gitStatus, headToIndexRenameDetails, indexToWorkDirRenameDetails);
if (gitStatus == FileStatus.Unaltered)
{
unaltered.Add(statusEntry);
}
else
{
foreach (KeyValuePair <FileStatus, Action <RepositoryStatus, StatusEntry> > kvp in dispatcher)
{
if (!gitStatus.HasFlag(kvp.Key))
{
continue;
}
kvp.Value(this, statusEntry);
}
}
statusEntries.Add(statusEntry);
}
private int OnGitCheckoutNotify(
CheckoutNotifyFlags why,
IntPtr pathPtr,
IntPtr baselinePtr,
IntPtr targetPtr,
IntPtr workdirPtr,
IntPtr payloadPtr)
{
bool result = true;
if (this.onCheckoutNotify != null)
{
FilePath path = LaxFilePathMarshaler.FromNative(pathPtr) ?? FilePath.Empty;
result = onCheckoutNotify(path.Native, why);
}
return(Proxy.ConvertResultToCancelFlag(result));
}
internal static unsafe IndexEntry BuildFromPtr(git_index_entry *entry)
{
if (entry == null)
{
return(null);
}
FilePath path = LaxFilePathMarshaler.FromNative(entry->path);
return(new IndexEntry
{
Path = path.Native,
Id = new ObjectId(entry->id.Id),
StageLevel = Proxy.git_index_entry_stage(entry),
Mode = (Mode)entry->mode,
AssumeUnchanged = (git_index_entry.GIT_IDXENTRY_VALID & entry->flags) == git_index_entry.GIT_IDXENTRY_VALID
});
}
internal static IndexEntry BuildFromPtr(IndexEntrySafeHandle handle)
{
if (handle == null || handle.IsZero)
{
return(null);
}
GitIndexEntry entry = handle.MarshalAsGitIndexEntry();
FilePath path = LaxFilePathMarshaler.FromNative(entry.Path);
return(new IndexEntry
{
Path = path.Native,
Id = entry.Id,
StageLevel = Proxy.git_index_entry_stage(handle),
Mode = (Mode)entry.Mode
});
}
private unsafe int PrintCallBack(git_diff_delta *delta, GitDiffHunk hunk, GitDiffLine line, IntPtr payload)
{
string patchPart = LaxUtf8Marshaler.FromNative(line.content, (int)line.contentLen);
// Deleted files mean no "new file" path
var pathPtr = delta->new_file.Path != null
? delta->new_file.Path
: delta->old_file.Path;
var filePath = LaxFilePathMarshaler.FromNative(pathPtr);
PatchEntryChanges currentChange = this[filePath];
string prefix = string.Empty;
switch (line.lineOrigin)
{
case GitDiffLineOrigin.GIT_DIFF_LINE_CONTEXT:
prefix = " ";
break;
case GitDiffLineOrigin.GIT_DIFF_LINE_ADDITION:
linesAdded++;
currentChange.LinesAdded++;
currentChange.AddedLines.Add(new Line(line.NewLineNo, patchPart));
prefix = "+";
break;
case GitDiffLineOrigin.GIT_DIFF_LINE_DELETION:
linesDeleted++;
currentChange.LinesDeleted++;
currentChange.DeletedLines.Add(new Line(line.OldLineNo, patchPart));
prefix = "-";
break;
}
string formattedOutput = string.Concat(prefix, patchPart);
fullPatchBuilder.Append(formattedOutput);
currentChange.AppendToPatch(formattedOutput);
return(0);
}
private void AddFileChange(GitDiffDelta delta)
{
var newFilePath = LaxFilePathMarshaler.FromNative(delta.NewFile.Path);
var oldFilePath = LaxFilePathMarshaler.FromNative(delta.OldFile.Path);
var newMode = (Mode)delta.NewFile.Mode;
var oldMode = (Mode)delta.OldFile.Mode;
var newOid = delta.NewFile.Oid;
var oldOid = delta.OldFile.Oid;
if (delta.Status == ChangeKind.Untracked || delta.Status == ChangeKind.Ignored)
{
delta.Status = ChangeKind.Added;
}
var diffFile = new TreeEntryChanges(newFilePath, newMode, newOid, delta.Status, oldFilePath, oldMode, oldOid);
fileDispatcher[delta.Status](this, diffFile);
changes.Add(newFilePath, diffFile);
}
internal PatchStats(DiffSafeHandle diff)
{
int count = Proxy.git_diff_num_deltas(diff);
for (int i = 0; i < count; i++)
{
using (var patch = Proxy.git_patch_from_diff(diff, i))
{
var delta = Proxy.git_diff_get_delta(diff, i);
var pathPtr = delta.NewFile.Path != IntPtr.Zero ? delta.NewFile.Path : delta.OldFile.Path;
var newFilePath = LaxFilePathMarshaler.FromNative(pathPtr);
var stats = Proxy.git_patch_line_stats(patch);
int added = stats.Item1;
int deleted = stats.Item2;
changes.Add(newFilePath, new ContentChangeStats(added, deleted));
totalLinesAdded += added;
totalLinesDeleted += deleted;
}
}
}
private void AddStatusEntryForDelta(FileStatus gitStatus, GitDiffDelta deltaHeadToIndex, GitDiffDelta deltaIndexToWorkDir)
{
RenameDetails headToIndexRenameDetails = null;
RenameDetails indexToWorkDirRenameDetails = null;
if ((gitStatus & FileStatus.RenamedInIndex) == FileStatus.RenamedInIndex)
{
headToIndexRenameDetails = new RenameDetails(
LaxFilePathMarshaler.FromNative(deltaHeadToIndex.OldFile.Path).Native,
LaxFilePathMarshaler.FromNative(deltaHeadToIndex.NewFile.Path).Native,
(int)deltaHeadToIndex.Similarity);
}
if ((gitStatus & FileStatus.RenamedInWorkDir) == FileStatus.RenamedInWorkDir)
{
indexToWorkDirRenameDetails = new RenameDetails(
LaxFilePathMarshaler.FromNative(deltaIndexToWorkDir.OldFile.Path).Native,
LaxFilePathMarshaler.FromNative(deltaIndexToWorkDir.NewFile.Path).Native,
(int)deltaIndexToWorkDir.Similarity);
}
var filePath = (deltaIndexToWorkDir != null) ?
LaxFilePathMarshaler.FromNative(deltaIndexToWorkDir.NewFile.Path).Native :
LaxFilePathMarshaler.FromNative(deltaHeadToIndex.NewFile.Path).Native;
StatusEntry statusEntry = new StatusEntry(filePath, gitStatus, headToIndexRenameDetails, indexToWorkDirRenameDetails);
foreach (KeyValuePair <FileStatus, Action <RepositoryStatus, StatusEntry> > kvp in dispatcher)
{
if (!gitStatus.HasFlag(kvp.Key))
{
continue;
}
kvp.Value(this, statusEntry);
}
statusEntries.Add(statusEntry);
}
internal static IndexReucEntry BuildFromPtr(IndexReucEntrySafeHandle handle)
{
if (handle == null || handle.IsZero)
{
return(null);
}
GitIndexReucEntry entry = handle.MarshalAsGitIndexReucEntry();
FilePath path = LaxFilePathMarshaler.FromNative(entry.Path);
return(new IndexReucEntry
{
Path = path.Native,
AncestorId = entry.AncestorId,
AncestorMode = (Mode)entry.AncestorMode,
OurId = entry.OurId,
OurMode = (Mode)entry.OurMode,
TheirId = entry.TheirId,
TheirMode = (Mode)entry.TheirMode,
});
}