Use pointers to read the index entries

carlosmn · carlosmn · commit 92fc8f540534 · 2015-12-16T13:35:07.000+01:00
diff --git a/LibGit2Sharp/Core/GitIndexEntry.cs b/LibGit2Sharp/Core/GitIndexEntry.cs
@@ -3,6 +3,30 @@
 
 namespace LibGit2Sharp.Core
 {
+    [StructLayout(LayoutKind.Sequential)]
+    internal unsafe struct git_index_mtime
+    {
+        public int seconds;
+        public uint nanoseconds;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal unsafe struct git_index_entry
+    {
+        public git_index_mtime ctime;
+        public git_index_mtime mtime;
+        public uint dev;
+        public uint ino;
+        public uint mode;
+        public uint uid;
+        public uint gid;
+        public uint file_size;
+        public git_oid id;
+        public ushort flags;
+        public ushort extended_flags;
+        public char* path;
+    }
+
     [StructLayout(LayoutKind.Sequential)]
     internal class GitIndexEntry
     {
diff --git a/LibGit2Sharp/Core/NativeMethods.cs b/LibGit2Sharp/Core/NativeMethods.cs
@@ -634,10 +634,10 @@ internal static extern int git_index_add(
             GitIndexEntry entry);
 
         [DllImport(libgit2)]
-        internal static extern int git_index_conflict_get(
-            out IndexEntrySafeHandle ancestor,
-            out IndexEntrySafeHandle ours,
-            out IndexEntrySafeHandle theirs,
+        internal static extern unsafe int git_index_conflict_get(
+            out git_index_entry* ancestor,
+            out git_index_entry* ours,
+            out git_index_entry* theirs,
             IndexSafeHandle index,
             [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictFilePathMarshaler))] FilePath path);
 
@@ -647,10 +647,10 @@ internal static extern int git_index_conflict_iterator_new(
             IndexSafeHandle index);
 
         [DllImport(libgit2)]
-        internal static extern int git_index_conflict_next(
-            out IndexEntrySafeHandle ancestor,
-            out IndexEntrySafeHandle ours,
-            out IndexEntrySafeHandle theirs,
+        internal static extern unsafe int git_index_conflict_next(
+            out git_index_entry* ancestor,
+            out git_index_entry* ours,
+            out git_index_entry* theirs,
             ConflictIteratorSafeHandle iterator);
 
         [DllImport(libgit2)]
@@ -661,16 +661,16 @@ internal static extern void git_index_conflict_iterator_free(
         internal static extern UIntPtr git_index_entrycount(IndexSafeHandle index);
 
         [DllImport(libgit2)]
-        internal static extern int git_index_entry_stage(IndexEntrySafeHandle indexentry);
+        internal static extern unsafe int git_index_entry_stage(git_index_entry* indexentry);
 
         [DllImport(libgit2)]
         internal static extern void git_index_free(IntPtr index);
 
         [DllImport(libgit2)]
-        internal static extern IndexEntrySafeHandle git_index_get_byindex(IndexSafeHandle index, UIntPtr n);
+        internal static extern unsafe git_index_entry* git_index_get_byindex(IndexSafeHandle index, UIntPtr n);
 
         [DllImport(libgit2)]
-        internal static extern IndexEntrySafeHandle git_index_get_bypath(
+        internal static extern unsafe git_index_entry* git_index_get_bypath(
             IndexSafeHandle index,
             [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictFilePathMarshaler))] FilePath path,
             int stage);
diff --git a/LibGit2Sharp/Core/Proxy.cs b/LibGit2Sharp/Core/Proxy.cs
@@ -905,11 +905,11 @@ public static void git_index_add_bypath(IndexSafeHandle index, FilePath path)
             Ensure.ZeroResult(res);
         }
 
-        public static Conflict git_index_conflict_get(
+        public static unsafe Conflict git_index_conflict_get(
             IndexSafeHandle index,
             FilePath path)
         {
-            IndexEntrySafeHandle ancestor, ours, theirs;
+            git_index_entry* ancestor, ours, theirs;
 
             int res = NativeMethods.git_index_conflict_get(out ancestor,
                                                            out ours,
@@ -938,9 +938,9 @@ public static ConflictIteratorSafeHandle git_index_conflict_iterator_new(IndexSa
             return iter;
         }
 
-        public static Conflict git_index_conflict_next(ConflictIteratorSafeHandle iterator)
+        public static unsafe Conflict git_index_conflict_next(ConflictIteratorSafeHandle iterator)
         {
-            IndexEntrySafeHandle ancestor, ours, theirs;
+            git_index_entry* ancestor, ours, theirs;
 
             int res = NativeMethods.git_index_conflict_next(out ancestor, out ours, out theirs, iterator);
 
@@ -951,14 +951,9 @@ public static Conflict git_index_conflict_next(ConflictIteratorSafeHandle iterat
 
             Ensure.ZeroResult(res);
 
-            using (ancestor)
-            using (ours)
-            using (theirs)
-            {
-                return new Conflict(IndexEntry.BuildFromPtr(ancestor),
-                                    IndexEntry.BuildFromPtr(ours),
-                                    IndexEntry.BuildFromPtr(theirs));
-            }
+            return new Conflict(IndexEntry.BuildFromPtr(ancestor),
+                                IndexEntry.BuildFromPtr(ours),
+                                IndexEntry.BuildFromPtr(theirs));
         }
 
         public static void git_index_conflict_iterator_free(IntPtr iterator)
@@ -972,26 +967,24 @@ public static int git_index_entrycount(IndexSafeHandle index)
                 .ConvertToInt();
         }
 
-        public static StageLevel git_index_entry_stage(IndexEntrySafeHandle index)
+        public static unsafe StageLevel git_index_entry_stage(git_index_entry* entry)
         {
-            return (StageLevel)NativeMethods.git_index_entry_stage(index);
+            return (StageLevel)NativeMethods.git_index_entry_stage(entry);
         }
 
         public static void git_index_free(IntPtr index)
         {
             NativeMethods.git_index_free(index);
         }
 
-        public static IndexEntrySafeHandle git_index_get_byindex(IndexSafeHandle index, UIntPtr n)
+        public static unsafe git_index_entry* git_index_get_byindex(IndexSafeHandle index, UIntPtr n)
         {
             return NativeMethods.git_index_get_byindex(index, n);
         }
 
-        public static IndexEntrySafeHandle git_index_get_bypath(IndexSafeHandle index, FilePath path, int stage)
+        public static unsafe git_index_entry* git_index_get_bypath(IndexSafeHandle index, FilePath path, int stage)
         {
-            IndexEntrySafeHandle handle = NativeMethods.git_index_get_bypath(index, path, stage);
-
-            return handle.IsZero ? null : handle;
+            return NativeMethods.git_index_get_bypath(index, path, stage);
         }
 
         public static bool git_index_has_conflicts(IndexSafeHandle index)
diff --git a/LibGit2Sharp/Index.cs b/LibGit2Sharp/Index.cs
@@ -70,22 +70,22 @@ public virtual bool IsFullyMerged
         /// <summary>
         /// Gets the <see cref="IndexEntry"/> with the specified relative path.
         /// </summary>
-        public virtual IndexEntry this[string path]
+        public virtual unsafe IndexEntry this[string path]
         {
             get
             {
                 Ensure.ArgumentNotNullOrEmptyString(path, "path");
 
-                IndexEntrySafeHandle entryHandle = Proxy.git_index_get_bypath(handle, path, 0);
-                return IndexEntry.BuildFromPtr(entryHandle);
+                git_index_entry* entry = Proxy.git_index_get_bypath(handle, path, 0);
+                return IndexEntry.BuildFromPtr(entry);
             }
         }
 
-        private IndexEntry this[int index]
+        private unsafe IndexEntry this[int index]
         {
             get
             {
-                IndexEntrySafeHandle entryHandle = Proxy.git_index_get_byindex(handle, (UIntPtr)index);
+                git_index_entry* entryHandle = Proxy.git_index_get_byindex(handle, (UIntPtr)index);
                 return IndexEntry.BuildFromPtr(entryHandle);
             }
         }
diff --git a/LibGit2Sharp/IndexEntry.cs b/LibGit2Sharp/IndexEntry.cs
@@ -40,24 +40,22 @@ public class IndexEntry : IEquatable<IndexEntry>
         /// </summary>
         public virtual ObjectId Id { get; private set; }
 
-        internal static IndexEntry BuildFromPtr(IndexEntrySafeHandle handle)
+        internal static unsafe IndexEntry BuildFromPtr(git_index_entry* entry)
         {
-            if (handle == null || handle.IsZero)
+            if (entry == null)
             {
                 return null;
             }
 
-            GitIndexEntry entry = handle.MarshalAsGitIndexEntry();
-
-            FilePath path = LaxFilePathMarshaler.FromNative(entry.Path);
+            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,
-                AssumeUnchanged = (GitIndexEntry.GIT_IDXENTRY_VALID & entry.Flags) == GitIndexEntry.GIT_IDXENTRY_VALID
+                Id = new ObjectId(entry->id.Id),
+                StageLevel = Proxy.git_index_entry_stage(entry),
+                Mode = (Mode)entry->mode,
+                AssumeUnchanged = (GitIndexEntry.GIT_IDXENTRY_VALID & entry->flags) == GitIndexEntry.GIT_IDXENTRY_VALID
             };
         }
 

Original file line number	Diff line number	Diff line change
`@@ -905,11 +905,11 @@ public static void git_index_add_bypath(IndexSafeHandle index, FilePath path)`
`905`	`905`	`Ensure.ZeroResult(res);`
`906`	`906`	`}`
`907`	`907`
`908`		`- public static Conflict git_index_conflict_get(`
	`908`	`+ public static unsafe Conflict git_index_conflict_get(`
`909`	`909`	`IndexSafeHandle index,`
`910`	`910`	`FilePath path)`
`911`	`911`	`{`
`912`		`- IndexEntrySafeHandle ancestor, ours, theirs;`
	`912`	`+ git_index_entry* ancestor, ours, theirs;`
`913`	`913`
`914`	`914`	`int res = NativeMethods.git_index_conflict_get(out ancestor,`
`915`	`915`	`out ours,`
`@@ -938,9 +938,9 @@ public static ConflictIteratorSafeHandle git_index_conflict_iterator_new(IndexSa`
`938`	`938`	`return iter;`
`939`	`939`	`}`
`940`	`940`
`941`		`- public static Conflict git_index_conflict_next(ConflictIteratorSafeHandle iterator)`
	`941`	`+ public static unsafe Conflict git_index_conflict_next(ConflictIteratorSafeHandle iterator)`
`942`	`942`	`{`
`943`		`- IndexEntrySafeHandle ancestor, ours, theirs;`
	`943`	`+ git_index_entry* ancestor, ours, theirs;`
`944`	`944`
`945`	`945`	`int res = NativeMethods.git_index_conflict_next(out ancestor, out ours, out theirs, iterator);`
`946`	`946`
`@@ -951,14 +951,9 @@ public static Conflict git_index_conflict_next(ConflictIteratorSafeHandle iterat`
`951`	`951`
`952`	`952`	`Ensure.ZeroResult(res);`
`953`	`953`
`954`		`- using (ancestor)`
`955`		`- using (ours)`
`956`		`- using (theirs)`
`957`		`- {`
`958`		`- return new Conflict(IndexEntry.BuildFromPtr(ancestor),`
`959`		`- IndexEntry.BuildFromPtr(ours),`
`960`		`- IndexEntry.BuildFromPtr(theirs));`
`961`		`- }`
	`954`	`+ return new Conflict(IndexEntry.BuildFromPtr(ancestor),`
	`955`	`+ IndexEntry.BuildFromPtr(ours),`
	`956`	`+ IndexEntry.BuildFromPtr(theirs));`
`962`	`957`	`}`
`963`	`958`
`964`	`959`	`public static void git_index_conflict_iterator_free(IntPtr iterator)`
`@@ -972,26 +967,24 @@ public static int git_index_entrycount(IndexSafeHandle index)`
`972`	`967`	`.ConvertToInt();`
`973`	`968`	`}`
`974`	`969`
`975`		`- public static StageLevel git_index_entry_stage(IndexEntrySafeHandle index)`
	`970`	`+ public static unsafe StageLevel git_index_entry_stage(git_index_entry* entry)`
`976`	`971`	`{`
`977`		`- return (StageLevel)NativeMethods.git_index_entry_stage(index);`
	`972`	`+ return (StageLevel)NativeMethods.git_index_entry_stage(entry);`
`978`	`973`	`}`
`979`	`974`
`980`	`975`	`public static void git_index_free(IntPtr index)`
`981`	`976`	`{`
`982`	`977`	`NativeMethods.git_index_free(index);`
`983`	`978`	`}`
`984`	`979`
`985`		`- public static IndexEntrySafeHandle git_index_get_byindex(IndexSafeHandle index, UIntPtr n)`
	`980`	`+ public static unsafe git_index_entry* git_index_get_byindex(IndexSafeHandle index, UIntPtr n)`
`986`	`981`	`{`
`987`	`982`	`return NativeMethods.git_index_get_byindex(index, n);`
`988`	`983`	`}`
`989`	`984`
`990`		`- public static IndexEntrySafeHandle git_index_get_bypath(IndexSafeHandle index, FilePath path, int stage)`
	`985`	`+ public static unsafe git_index_entry* git_index_get_bypath(IndexSafeHandle index, FilePath path, int stage)`
`991`	`986`	`{`
`992`		`- IndexEntrySafeHandle handle = NativeMethods.git_index_get_bypath(index, path, stage);`
`993`		`-`
`994`		`- return handle.IsZero ? null : handle;`
	`987`	`+ return NativeMethods.git_index_get_bypath(index, path, stage);`
`995`	`988`	`}`
`996`	`989`
`997`	`990`	`public static bool git_index_has_conflicts(IndexSafeHandle index)`
Original file line number	Diff line number	Diff line change
`@@ -70,22 +70,22 @@ public virtual bool IsFullyMerged`
`70`	`70`	`/// <summary>`
`71`	`71`	`/// Gets the <see cref="IndexEntry"/> with the specified relative path.`
`72`	`72`	`/// </summary>`
`73`		`- public virtual IndexEntry this[string path]`
	`73`	`+ public virtual unsafe IndexEntry this[string path]`
`74`	`74`	`{`
`75`	`75`	`get`
`76`	`76`	`{`
`77`	`77`	`Ensure.ArgumentNotNullOrEmptyString(path, "path");`
`78`	`78`
`79`		`- IndexEntrySafeHandle entryHandle = Proxy.git_index_get_bypath(handle, path, 0);`
`80`		`- return IndexEntry.BuildFromPtr(entryHandle);`
	`79`	`+ git_index_entry* entry = Proxy.git_index_get_bypath(handle, path, 0);`
	`80`	`+ return IndexEntry.BuildFromPtr(entry);`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`
`84`		`- private IndexEntry this[int index]`
	`84`	`+ private unsafe IndexEntry this[int index]`
`85`	`85`	`{`
`86`	`86`	`get`
`87`	`87`	`{`
`88`		`- IndexEntrySafeHandle entryHandle = Proxy.git_index_get_byindex(handle, (UIntPtr)index);`
	`88`	`+ git_index_entry* entryHandle = Proxy.git_index_get_byindex(handle, (UIntPtr)index);`
`89`	`89`	`return IndexEntry.BuildFromPtr(entryHandle);`
`90`	`90`	`}`
`91`	`91`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,24 +40,22 @@ public class IndexEntry : IEquatable<IndexEntry>`
`40`	`40`	`/// </summary>`
`41`	`41`	`public virtual ObjectId Id { get; private set; }`
`42`	`42`
`43`		`- internal static IndexEntry BuildFromPtr(IndexEntrySafeHandle handle)`
	`43`	`+ internal static unsafe IndexEntry BuildFromPtr(git_index_entry* entry)`
`44`	`44`	`{`
`45`		`- if (handle == null \|\| handle.IsZero)`
	`45`	`+ if (entry == null)`
`46`	`46`	`{`
`47`	`47`	`return null;`
`48`	`48`	`}`
`49`	`49`
`50`		`- GitIndexEntry entry = handle.MarshalAsGitIndexEntry();`
`51`		`-`
`52`		`- FilePath path = LaxFilePathMarshaler.FromNative(entry.Path);`
	`50`	`+ FilePath path = LaxFilePathMarshaler.FromNative(entry->path);`
`53`	`51`
`54`	`52`	`return new IndexEntry`
`55`	`53`	`{`
`56`	`54`	`Path = path.Native,`
`57`		`- Id = entry.Id,`
`58`		`- StageLevel = Proxy.git_index_entry_stage(handle),`
`59`		`- Mode = (Mode)entry.Mode,`
`60`		`- AssumeUnchanged = (GitIndexEntry.GIT_IDXENTRY_VALID & entry.Flags) == GitIndexEntry.GIT_IDXENTRY_VALID`
	`55`	`+ Id = new ObjectId(entry->id.Id),`
	`56`	`+ StageLevel = Proxy.git_index_entry_stage(entry),`
	`57`	`+ Mode = (Mode)entry->mode,`
	`58`	`+ AssumeUnchanged = (GitIndexEntry.GIT_IDXENTRY_VALID & entry->flags) == GitIndexEntry.GIT_IDXENTRY_VALID`
`61`	`59`	`};`
`62`	`60`	`}`
`63`	`61`