Get rid of StatusEntrySafeHandle

carlosmn · carlosmn · commit 1f50a0f8cdf3 · 2016-01-14T18:32:42.000+01:00
This includes using pointers for some diff entries, which this uses.
diff --git a/LibGit2Sharp/ContentChanges.cs b/LibGit2Sharp/ContentChanges.cs
@@ -20,7 +20,7 @@ public class ContentChanges
         protected ContentChanges()
         { }
 
-        internal ContentChanges(Repository repo, Blob oldBlob, Blob newBlob, GitDiffOptions options)
+        internal unsafe ContentChanges(Repository repo, Blob oldBlob, Blob newBlob, GitDiffOptions options)
         {
             Proxy.git_diff_blobs(repo.Handle,
                                  oldBlob != null ? oldBlob.Id : null,
@@ -64,9 +64,9 @@ public virtual string Patch
         /// </summary>
         public virtual bool IsBinaryComparison { get; private set; }
 
-        private int FileCallback(GitDiffDelta delta, float progress, IntPtr payload)
+        private unsafe int FileCallback(git_diff_delta* delta, float progress, IntPtr payload)
         {
-            IsBinaryComparison = delta.IsBinary();
+            IsBinaryComparison = delta->flags.HasFlag(GitDiffFlags.GIT_DIFF_FLAG_BINARY);
 
             if (!IsBinaryComparison)
             {
@@ -78,15 +78,15 @@ private int FileCallback(GitDiffDelta delta, float progress, IntPtr payload)
             return 0;
         }
 
-        private int HunkCallback(GitDiffDelta delta, GitDiffHunk hunk, IntPtr payload)
+        private unsafe int HunkCallback(git_diff_delta* delta, GitDiffHunk hunk, IntPtr payload)
         {
             string decodedContent = LaxUtf8Marshaler.FromBuffer(hunk.Header, (int)hunk.HeaderLen);
 
             AppendToPatch(decodedContent);
             return 0;
         }
 
-        private int LineCallback(GitDiffDelta delta, GitDiffHunk hunk, GitDiffLine line, IntPtr payload)
+        private unsafe int LineCallback(git_diff_delta* delta, GitDiffHunk hunk, GitDiffLine line, IntPtr payload)
         {
             string decodedContent = LaxUtf8Marshaler.FromNative(line.content, (int)line.contentLen);
 
diff --git a/LibGit2Sharp/Core/GitDiff.cs b/LibGit2Sharp/Core/GitDiff.cs
@@ -235,24 +235,24 @@ internal enum GitDiffFlags
     }
 
     [StructLayout(LayoutKind.Sequential)]
-    internal class GitDiffFile
+    internal unsafe struct git_diff_file
     {
-        public GitOid Id;
-        public IntPtr Path;
+        public git_oid Id;
+        public char* Path;
         public Int64 Size;
         public GitDiffFlags Flags;
         public UInt16 Mode;
     }
 
     [StructLayout(LayoutKind.Sequential)]
-    internal class GitDiffDelta
+    internal unsafe struct git_diff_delta
     {
-        public ChangeKind Status;
-        public GitDiffFlags Flags;
-        public UInt16 Similarity;
-        public UInt16 NumberOfFiles;
-        public GitDiffFile OldFile;
-        public GitDiffFile NewFile;
+        public ChangeKind status;
+        public GitDiffFlags flags;
+        public UInt16 similarity;
+        public UInt16 nfiles;
+        public git_diff_file old_file;
+        public git_diff_file new_file;
     }
 
     [StructLayout(LayoutKind.Sequential)]
diff --git a/LibGit2Sharp/Core/GitDiffExtensions.cs b/LibGit2Sharp/Core/GitDiffExtensions.cs
diff --git a/LibGit2Sharp/Core/GitStatusEntry.cs b/LibGit2Sharp/Core/GitStatusEntry.cs
@@ -7,21 +7,21 @@ namespace LibGit2Sharp.Core
     /// A status entry from libgit2.
     /// </summary>
     [StructLayout(LayoutKind.Sequential)]
-    internal class GitStatusEntry
+    internal unsafe struct git_status_entry
     {
         /// <summary>
         /// Calculated status of a filepath in the working directory considering the current <see cref = "Repository.Index" /> and the <see cref="Repository.Head" />.
         /// </summary>
-        public FileStatus Status;
+        public FileStatus status;
 
         /// <summary>
         /// The difference between the <see cref="Repository.Head" /> and <see cref = "Repository.Index" />.
         /// </summary>
-        public IntPtr HeadToIndexPtr;
+        public git_diff_delta* head_to_index;
 
         /// <summary>
         /// The difference between the <see cref = "Repository.Index" /> and the working directory.
         /// </summary>
-        public IntPtr IndexToWorkDirPtr;
+        public git_diff_delta* index_to_workdir;
     }
 }
diff --git a/LibGit2Sharp/Core/Handles/StatusEntrySafeHandle.cs b/LibGit2Sharp/Core/Handles/StatusEntrySafeHandle.cs
diff --git a/LibGit2Sharp/Core/NativeMethods.cs b/LibGit2Sharp/Core/NativeMethods.cs
@@ -512,24 +512,24 @@ internal static extern unsafe int git_diff_tree_to_workdir(
             GitObjectSafeHandle oldTree,
             GitDiffOptions options);
 
-        internal delegate int git_diff_file_cb(
-            [In] GitDiffDelta delta,
+        internal unsafe delegate int git_diff_file_cb(
+            [In] git_diff_delta* delta,
             float progress,
             IntPtr payload);
 
-        internal delegate int git_diff_hunk_cb(
-            [In] GitDiffDelta delta,
+        internal unsafe delegate int git_diff_hunk_cb(
+            [In] git_diff_delta* delta,
             [In] GitDiffHunk hunk,
             IntPtr payload);
 
-        internal delegate int git_diff_line_cb(
-            [In] GitDiffDelta delta,
+        internal unsafe delegate int git_diff_line_cb(
+            [In] git_diff_delta* delta,
             [In] GitDiffHunk hunk,
             [In] GitDiffLine line,
             IntPtr payload);
 
-        internal delegate int git_diff_binary_cb(
-            [In] GitDiffDelta delta,
+        internal unsafe delegate int git_diff_binary_cb(
+            [In] git_diff_delta* delta,
             [In] GitDiffBinary binary,
             IntPtr payload);
 
@@ -564,7 +564,7 @@ internal static extern int git_diff_find_similar(
         internal static extern UIntPtr git_diff_num_deltas(DiffSafeHandle diff);
 
         [DllImport(libgit2)]
-        internal static extern IntPtr git_diff_get_delta(DiffSafeHandle diff, UIntPtr idx);
+        internal static extern unsafe git_diff_delta* git_diff_get_delta(DiffSafeHandle diff, UIntPtr idx);
 
         [DllImport(libgit2)]
         internal static extern int git_filter_register(
@@ -1543,7 +1543,7 @@ internal static extern int git_status_list_entrycount(
             StatusListSafeHandle statusList);
 
         [DllImport(libgit2)]
-        internal static extern StatusEntrySafeHandle git_status_byindex(
+        internal static extern unsafe git_status_entry* git_status_byindex(
             StatusListSafeHandle list,
             UIntPtr idx);
 
diff --git a/LibGit2Sharp/Core/Proxy.cs b/LibGit2Sharp/Core/Proxy.cs
@@ -819,9 +819,9 @@ public static int git_diff_num_deltas(DiffSafeHandle diff)
             return (int)NativeMethods.git_diff_num_deltas(diff);
         }
 
-        public static GitDiffDelta git_diff_get_delta(DiffSafeHandle diff, int idx)
+        public static unsafe git_diff_delta* git_diff_get_delta(DiffSafeHandle diff, int idx)
         {
-            return NativeMethods.git_diff_get_delta(diff, (UIntPtr)idx).MarshalAs<GitDiffDelta>(false);
+            return NativeMethods.git_diff_get_delta(diff, (UIntPtr)idx);
         }
 
         #endregion
@@ -2853,7 +2853,7 @@ public static int git_status_list_entrycount(StatusListSafeHandle list)
             return res;
         }
 
-        public static StatusEntrySafeHandle git_status_byindex(StatusListSafeHandle list, long idx)
+        public static unsafe git_status_entry* git_status_byindex(StatusListSafeHandle list, long idx)
         {
             return NativeMethods.git_status_byindex(list, (UIntPtr)idx);
         }
diff --git a/LibGit2Sharp/LibGit2Sharp.csproj b/LibGit2Sharp/LibGit2Sharp.csproj
@@ -158,7 +158,6 @@
     <Compile Include="RefSpecDirection.cs" />
     <Compile Include="Core\GitStatusEntry.cs" />
     <Compile Include="Core\GitStatusOptions.cs" />
-    <Compile Include="Core\Handles\StatusEntrySafeHandle.cs" />
     <Compile Include="Core\Handles\StatusListSafeHandle.cs" />
     <Compile Include="RenameDetails.cs" />
     <Compile Include="RevertResult.cs" />
@@ -267,7 +266,6 @@
     <Compile Include="ChangeKind.cs" />
     <Compile Include="Core\GitBranchType.cs" />
     <Compile Include="Core\GitDiff.cs" />
-    <Compile Include="Core\GitDiffExtensions.cs" />
     <Compile Include="Core\GitDirection.cs" />
     <Compile Include="Core\GitError.cs" />
     <Compile Include="Core\GitErrorCategory.cs" />
diff --git a/LibGit2Sharp/Patch.cs b/LibGit2Sharp/Patch.cs
@@ -30,7 +30,7 @@ public class Patch : IEnumerable<PatchEntryChanges>, IDiffResult
         protected Patch()
         { }
 
-        internal Patch(DiffSafeHandle diff)
+        internal unsafe Patch(DiffSafeHandle diff)
         {
             int count = Proxy.git_diff_num_deltas(diff);
             for (int i = 0; i < count; i++)
@@ -44,22 +44,22 @@ internal Patch(DiffSafeHandle diff)
             }
         }
 
-        private void AddFileChange(GitDiffDelta delta)
+        private unsafe void AddFileChange(git_diff_delta* delta)
         {
             var treeEntryChanges = new TreeEntryChanges(delta);
 
-            changes.Add(treeEntryChanges.Path, new PatchEntryChanges(delta.IsBinary(), treeEntryChanges));
+            changes.Add(treeEntryChanges.Path, new PatchEntryChanges(delta->flags.HasFlag(GitDiffFlags.GIT_DIFF_FLAG_BINARY), treeEntryChanges));
         }
 
-        private int PrintCallBack(GitDiffDelta delta, GitDiffHunk hunk, GitDiffLine line, IntPtr payload)
+        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.NewFile.Path != IntPtr.Zero
-                ? delta.NewFile.Path
-                : delta.OldFile.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];
diff --git a/LibGit2Sharp/PatchStats.cs b/LibGit2Sharp/PatchStats.cs
@@ -25,15 +25,15 @@ public class PatchStats : IEnumerable<ContentChangeStats>, IDiffResult
         protected PatchStats()
         { }
 
-        internal PatchStats(DiffSafeHandle diff)
+        internal unsafe 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 pathPtr = delta->new_file.Path != null ? delta->new_file.Path : delta->old_file.Path;
                     var newFilePath = LaxFilePathMarshaler.FromNative(pathPtr);
 
                     var stats = Proxy.git_patch_line_stats(patch);
diff --git a/LibGit2Sharp/RepositoryStatus.cs b/LibGit2Sharp/RepositoryStatus.cs
@@ -53,7 +53,7 @@ private static IDictionary<FileStatus, Action<RepositoryStatus, StatusEntry>> Bu
         protected RepositoryStatus()
         { }
 
-        internal RepositoryStatus(Repository repo, StatusOptions options)
+        internal unsafe RepositoryStatus(Repository repo, StatusOptions options)
         {
             statusEntries = new List<StatusEntry>();
 
@@ -64,22 +64,8 @@ internal RepositoryStatus(Repository repo, StatusOptions options)
 
                 for (int i = 0; i < count; i++)
                 {
-                    StatusEntrySafeHandle e = Proxy.git_status_byindex(list, i);
-                    GitStatusEntry entry = e.MarshalAsGitStatusEntry();
-
-                    GitDiffDelta deltaHeadToIndex = null;
-                    GitDiffDelta deltaIndexToWorkDir = null;
-
-                    if (entry.HeadToIndexPtr != IntPtr.Zero)
-                    {
-                        deltaHeadToIndex = entry.HeadToIndexPtr.MarshalAs<GitDiffDelta>();
-                    }
-                    if (entry.IndexToWorkDirPtr != IntPtr.Zero)
-                    {
-                        deltaIndexToWorkDir = entry.IndexToWorkDirPtr.MarshalAs<GitDiffDelta>();
-                    }
-
-                    AddStatusEntryForDelta(entry.Status, deltaHeadToIndex, deltaIndexToWorkDir);
+                    git_status_entry *entry = Proxy.git_status_byindex(list, i);
+                    AddStatusEntryForDelta(entry->status, entry->head_to_index, entry->index_to_workdir);
                 }
 
                 isDirty = statusEntries.Any(entry => entry.State != FileStatus.Ignored && entry.State != FileStatus.Unaltered);
@@ -144,30 +130,30 @@ private static GitStatusOptions CreateStatusOptions(StatusOptions options)
             return coreOptions;
         }
 
-        private void AddStatusEntryForDelta(FileStatus gitStatus, GitDiffDelta deltaHeadToIndex, GitDiffDelta deltaIndexToWorkDir)
+        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.OldFile.Path).Native,
-                                      LaxFilePathMarshaler.FromNative(deltaHeadToIndex.NewFile.Path).Native,
-                                      (int)deltaHeadToIndex.Similarity);
+                    new RenameDetails(LaxFilePathMarshaler.FromNative(deltaHeadToIndex->old_file.Path),
+                                      LaxFilePathMarshaler.FromNative(deltaHeadToIndex->new_file.Path),
+                                      (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);
+                    new RenameDetails(LaxFilePathMarshaler.FromNative(deltaIndexToWorkDir->old_file.Path),
+                                      LaxFilePathMarshaler.FromNative(deltaIndexToWorkDir->new_file.Path),
+                                      (int)deltaIndexToWorkDir->similarity);
             }
 
             var filePath = (deltaIndexToWorkDir != null)
-                ? LaxFilePathMarshaler.FromNative(deltaIndexToWorkDir.NewFile.Path).Native
-                : LaxFilePathMarshaler.FromNative(deltaHeadToIndex.NewFile.Path).Native;
+                ? LaxFilePathMarshaler.FromNative(deltaIndexToWorkDir->new_file.Path)
+                : LaxFilePathMarshaler.FromNative(deltaHeadToIndex->new_file.Path);
 
             StatusEntry statusEntry = new StatusEntry(filePath, gitStatus, headToIndexRenameDetails, indexToWorkDirRenameDetails);
 
diff --git a/LibGit2Sharp/TreeChanges.cs b/LibGit2Sharp/TreeChanges.cs
@@ -50,18 +50,18 @@ private static IDictionary<ChangeKind, Action<TreeChanges, TreeEntryChanges>> Bu
         protected TreeChanges()
         { }
 
-        internal TreeChanges(DiffSafeHandle diff)
+        internal unsafe TreeChanges(DiffSafeHandle diff)
         {
             Proxy.git_diff_foreach(diff, FileCallback, null, null);
         }
 
-        private int FileCallback(GitDiffDelta delta, float progress, IntPtr payload)
+        private unsafe int FileCallback(git_diff_delta* delta, float progress, IntPtr payload)
         {
             AddFileChange(delta);
             return 0;
         }
 
-        private void AddFileChange(GitDiffDelta delta)
+        private unsafe void AddFileChange(git_diff_delta* delta)
         {
             var treeEntryChanges = new TreeEntryChanges(delta);
 
diff --git a/LibGit2Sharp/TreeEntryChanges.cs b/LibGit2Sharp/TreeEntryChanges.cs

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public class ContentChanges`
`20`	`20`	`protected ContentChanges()`
`21`	`21`	`{ }`
`22`	`22`
`23`		`- internal ContentChanges(Repository repo, Blob oldBlob, Blob newBlob, GitDiffOptions options)`
	`23`	`+ internal unsafe ContentChanges(Repository repo, Blob oldBlob, Blob newBlob, GitDiffOptions options)`
`24`	`24`	`{`
`25`	`25`	`Proxy.git_diff_blobs(repo.Handle,`
`26`	`26`	`oldBlob != null ? oldBlob.Id : null,`
`@@ -64,9 +64,9 @@ public virtual string Patch`
`64`	`64`	`/// </summary>`
`65`	`65`	`public virtual bool IsBinaryComparison { get; private set; }`
`66`	`66`
`67`		`- private int FileCallback(GitDiffDelta delta, float progress, IntPtr payload)`
	`67`	`+ private unsafe int FileCallback(git_diff_delta* delta, float progress, IntPtr payload)`
`68`	`68`	`{`
`69`		`- IsBinaryComparison = delta.IsBinary();`
	`69`	`+ IsBinaryComparison = delta->flags.HasFlag(GitDiffFlags.GIT_DIFF_FLAG_BINARY);`
`70`	`70`
`71`	`71`	`if (!IsBinaryComparison)`
`72`	`72`	`{`
`@@ -78,15 +78,15 @@ private int FileCallback(GitDiffDelta delta, float progress, IntPtr payload)`
`78`	`78`	`return 0;`
`79`	`79`	`}`
`80`	`80`
`81`		`- private int HunkCallback(GitDiffDelta delta, GitDiffHunk hunk, IntPtr payload)`
	`81`	`+ private unsafe int HunkCallback(git_diff_delta* delta, GitDiffHunk hunk, IntPtr payload)`
`82`	`82`	`{`
`83`	`83`	`string decodedContent = LaxUtf8Marshaler.FromBuffer(hunk.Header, (int)hunk.HeaderLen);`
`84`	`84`
`85`	`85`	`AppendToPatch(decodedContent);`
`86`	`86`	`return 0;`
`87`	`87`	`}`
`88`	`88`
`89`		`- private int LineCallback(GitDiffDelta delta, GitDiffHunk hunk, GitDiffLine line, IntPtr payload)`
	`89`	`+ private unsafe int LineCallback(git_diff_delta* delta, GitDiffHunk hunk, GitDiffLine line, IntPtr payload)`
`90`	`90`	`{`
`91`	`91`	`string decodedContent = LaxUtf8Marshaler.FromNative(line.content, (int)line.contentLen);`
`92`	`92`
Original file line number	Diff line number	Diff line change
`@@ -819,9 +819,9 @@ public static int git_diff_num_deltas(DiffSafeHandle diff)`
`819`	`819`	`return (int)NativeMethods.git_diff_num_deltas(diff);`
`820`	`820`	`}`
`821`	`821`
`822`		`- public static GitDiffDelta git_diff_get_delta(DiffSafeHandle diff, int idx)`
	`822`	`+ public static unsafe git_diff_delta* git_diff_get_delta(DiffSafeHandle diff, int idx)`
`823`	`823`	`{`
`824`		`- return NativeMethods.git_diff_get_delta(diff, (UIntPtr)idx).MarshalAs<GitDiffDelta>(false);`
	`824`	`+ return NativeMethods.git_diff_get_delta(diff, (UIntPtr)idx);`
`825`	`825`	`}`
`826`	`826`
`827`	`827`	`#endregion`
`@@ -2853,7 +2853,7 @@ public static int git_status_list_entrycount(StatusListSafeHandle list)`
`2853`	`2853`	`return res;`
`2854`	`2854`	`}`
`2855`	`2855`
`2856`		`- public static StatusEntrySafeHandle git_status_byindex(StatusListSafeHandle list, long idx)`
	`2856`	`+ public static unsafe git_status_entry* git_status_byindex(StatusListSafeHandle list, long idx)`
`2857`	`2857`	`{`
`2858`	`2858`	`return NativeMethods.git_status_byindex(list, (UIntPtr)idx);`
`2859`	`2859`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public class Patch : IEnumerable<PatchEntryChanges>, IDiffResult`
`30`	`30`	`protected Patch()`
`31`	`31`	`{ }`
`32`	`32`
`33`		`- internal Patch(DiffSafeHandle diff)`
	`33`	`+ internal unsafe Patch(DiffSafeHandle diff)`
`34`	`34`	`{`
`35`	`35`	`int count = Proxy.git_diff_num_deltas(diff);`
`36`	`36`	`for (int i = 0; i < count; i++)`
`@@ -44,22 +44,22 @@ internal Patch(DiffSafeHandle diff)`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
`47`		`- private void AddFileChange(GitDiffDelta delta)`
	`47`	`+ private unsafe void AddFileChange(git_diff_delta* delta)`
`48`	`48`	`{`
`49`	`49`	`var treeEntryChanges = new TreeEntryChanges(delta);`
`50`	`50`
`51`		`- changes.Add(treeEntryChanges.Path, new PatchEntryChanges(delta.IsBinary(), treeEntryChanges));`
	`51`	`+ changes.Add(treeEntryChanges.Path, new PatchEntryChanges(delta->flags.HasFlag(GitDiffFlags.GIT_DIFF_FLAG_BINARY), treeEntryChanges));`
`52`	`52`	`}`
`53`	`53`
`54`		`- private int PrintCallBack(GitDiffDelta delta, GitDiffHunk hunk, GitDiffLine line, IntPtr payload)`
	`54`	`+ private unsafe int PrintCallBack(git_diff_delta* delta, GitDiffHunk hunk, GitDiffLine line, IntPtr payload)`
`55`	`55`	`{`
`56`	`56`	`string patchPart = LaxUtf8Marshaler.FromNative(line.content, (int)line.contentLen);`
`57`	`57`
`58`	`58`	`// Deleted files mean no "new file" path`
`59`	`59`
`60`		`- var pathPtr = delta.NewFile.Path != IntPtr.Zero`
`61`		`- ? delta.NewFile.Path`
`62`		`- : delta.OldFile.Path;`
	`60`	`+ var pathPtr = delta->new_file.Path != null`
	`61`	`+ ? delta->new_file.Path`
	`62`	`+ : delta->old_file.Path;`
`63`	`63`	`var filePath = LaxFilePathMarshaler.FromNative(pathPtr);`
`64`	`64`
`65`	`65`	`PatchEntryChanges currentChange = this[filePath];`
Original file line number	Diff line number	Diff line change
`@@ -25,15 +25,15 @@ public class PatchStats : IEnumerable<ContentChangeStats>, IDiffResult`
`25`	`25`	`protected PatchStats()`
`26`	`26`	`{ }`
`27`	`27`
`28`		`- internal PatchStats(DiffSafeHandle diff)`
	`28`	`+ internal unsafe PatchStats(DiffSafeHandle diff)`
`29`	`29`	`{`
`30`	`30`	`int count = Proxy.git_diff_num_deltas(diff);`
`31`	`31`	`for (int i = 0; i < count; i++)`
`32`	`32`	`{`
`33`	`33`	`using (var patch = Proxy.git_patch_from_diff(diff, i))`
`34`	`34`	`{`
`35`	`35`	`var delta = Proxy.git_diff_get_delta(diff, i);`
`36`		`- var pathPtr = delta.NewFile.Path != IntPtr.Zero ? delta.NewFile.Path : delta.OldFile.Path;`
	`36`	`+ var pathPtr = delta->new_file.Path != null ? delta->new_file.Path : delta->old_file.Path;`
`37`	`37`	`var newFilePath = LaxFilePathMarshaler.FromNative(pathPtr);`
`38`	`38`
`39`	`39`	`var stats = Proxy.git_patch_line_stats(patch);`