Use pointers for tree entries

carlosmn · carlosmn · commit e5aa4fbfe42a · 2015-12-11T03:39:23.000+01:00
We wrap the owned handle in a IDisposable to keep the using() pattern.
diff --git a/LibGit2Sharp/Core/Handles/TreeEntryOwnedHandle.cs b/LibGit2Sharp/Core/Handles/TreeEntryOwnedHandle.cs
@@ -0,0 +1,19 @@
+﻿using System;
+
+namespace LibGit2Sharp.Core.Handles
+{
+    internal unsafe class TreeEntryOwnedHandle : IDisposable
+    {
+        internal git_tree_entry* Handle { get; set; }
+
+        internal TreeEntryOwnedHandle(git_tree_entry* entry)
+        {
+            Handle = entry;
+        }
+
+        public void Dispose()
+        {
+            Proxy.git_tree_entry_free(Handle);
+        }
+    }
+}
diff --git a/LibGit2Sharp/Core/Handles/TreeEntrySafeHandle_Owned.cs b/LibGit2Sharp/Core/Handles/TreeEntrySafeHandle_Owned.cs
diff --git a/LibGit2Sharp/Core/NativeMethods.cs b/LibGit2Sharp/Core/NativeMethods.cs
@@ -1737,29 +1737,29 @@ internal static extern int git_transport_unregister(
             [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string prefix);
 
         [DllImport(libgit2)]
-        internal static extern uint git_tree_entry_filemode(SafeHandle entry);
+        internal static extern unsafe uint git_tree_entry_filemode(git_tree_entry* entry);
 
         [DllImport(libgit2)]
-        internal static extern TreeEntrySafeHandle git_tree_entry_byindex(GitObjectSafeHandle tree, UIntPtr idx);
+        internal static extern unsafe git_tree_entry* git_tree_entry_byindex(GitObjectSafeHandle tree, UIntPtr idx);
 
         [DllImport(libgit2)]
-        internal static extern int git_tree_entry_bypath(
-            out TreeEntrySafeHandle_Owned tree,
+        internal static extern unsafe int git_tree_entry_bypath(
+            out git_tree_entry* tree,
             GitObjectSafeHandle root,
             [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictFilePathMarshaler))] FilePath treeentry_path);
 
         [DllImport(libgit2)]
-        internal static extern void git_tree_entry_free(IntPtr treeEntry);
+        internal static extern unsafe void git_tree_entry_free(git_tree_entry* treeEntry);
 
         [DllImport(libgit2)]
-        internal static extern OidSafeHandle git_tree_entry_id(SafeHandle entry);
+        internal static extern unsafe OidSafeHandle git_tree_entry_id(git_tree_entry* entry);
 
         [DllImport(libgit2)]
         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(LaxUtf8NoCleanupMarshaler))]
-        internal static extern string git_tree_entry_name(SafeHandle entry);
+        internal static extern unsafe string git_tree_entry_name(git_tree_entry* entry);
 
         [DllImport(libgit2)]
-        internal static extern GitObjectType git_tree_entry_type(SafeHandle entry);
+        internal static extern unsafe GitObjectType git_tree_entry_type(git_tree_entry* entry);
 
         [DllImport(libgit2)]
         internal static extern UIntPtr git_tree_entrycount(GitObjectSafeHandle tree);
diff --git a/LibGit2Sharp/Core/Opaques.cs b/LibGit2Sharp/Core/Opaques.cs
@@ -0,0 +1,7 @@
+﻿using System;
+
+namespace LibGit2Sharp.Core
+{
+    internal struct git_tree_entry {}
+}
+
diff --git a/LibGit2Sharp/Core/Proxy.cs b/LibGit2Sharp/Core/Proxy.cs
@@ -3156,21 +3156,21 @@ public static void git_transport_unregister(String prefix)
 
         #region git_tree_
 
-        public static Mode git_tree_entry_attributes(SafeHandle entry)
+        public static unsafe Mode git_tree_entry_attributes(git_tree_entry* entry)
         {
             return (Mode)NativeMethods.git_tree_entry_filemode(entry);
         }
 
-        public static TreeEntrySafeHandle git_tree_entry_byindex(GitObjectSafeHandle tree, long idx)
+        public static unsafe git_tree_entry* git_tree_entry_byindex(GitObjectSafeHandle tree, long idx)
         {
             return NativeMethods.git_tree_entry_byindex(tree, (UIntPtr)idx);
         }
 
-        public static TreeEntrySafeHandle_Owned git_tree_entry_bypath(RepositorySafeHandle repo, ObjectId id, FilePath treeentry_path)
+        public static unsafe TreeEntryOwnedHandle git_tree_entry_bypath(RepositorySafeHandle repo, ObjectId id, FilePath treeentry_path)
         {
             using (var obj = new ObjectSafeWrapper(id, repo))
             {
-                TreeEntrySafeHandle_Owned treeEntryPtr;
+                git_tree_entry* treeEntryPtr;
                 int res = NativeMethods.git_tree_entry_bypath(out treeEntryPtr, obj.ObjectPtr, treeentry_path);
 
                 if (res == (int)GitErrorCode.NotFound)
@@ -3180,26 +3180,26 @@ public static TreeEntrySafeHandle_Owned git_tree_entry_bypath(RepositorySafeHand
 
                 Ensure.ZeroResult(res);
 
-                return treeEntryPtr;
+                return new TreeEntryOwnedHandle(treeEntryPtr);
             }
         }
 
-        public static void git_tree_entry_free(IntPtr treeEntry)
+        public static unsafe void git_tree_entry_free(git_tree_entry* treeEntry)
         {
             NativeMethods.git_tree_entry_free(treeEntry);
         }
 
-        public static ObjectId git_tree_entry_id(SafeHandle entry)
+        public static unsafe ObjectId git_tree_entry_id(git_tree_entry* entry)
         {
             return NativeMethods.git_tree_entry_id(entry).MarshalAsObjectId();
         }
 
-        public static string git_tree_entry_name(SafeHandle entry)
+        public static unsafe string git_tree_entry_name(git_tree_entry* entry)
         {
             return NativeMethods.git_tree_entry_name(entry);
         }
 
-        public static GitObjectType git_tree_entry_type(SafeHandle entry)
+        public static unsafe GitObjectType git_tree_entry_type(git_tree_entry* entry)
         {
             return NativeMethods.git_tree_entry_type(entry);
         }
diff --git a/LibGit2Sharp/LibGit2Sharp.csproj b/LibGit2Sharp/LibGit2Sharp.csproj
@@ -287,7 +287,6 @@
     <Compile Include="Core\Handles\NotOwnedSafeHandleBase.cs" />
     <Compile Include="Core\Handles\OidSafeHandle.cs" />
     <Compile Include="Core\Handles\TreeBuilderSafeHandle.cs" />
-    <Compile Include="Core\Handles\TreeEntrySafeHandle_Owned.cs" />
     <Compile Include="Core\Handles\ReferenceSafeHandle.cs" />
     <Compile Include="Core\Handles\SignatureSafeHandle.cs" />
     <Compile Include="Core\Handles\TreeEntrySafeHandle.cs" />
@@ -381,6 +380,8 @@
     <Compile Include="Core\GitCertificateSshType.cs" />
     <Compile Include="CertificateSsh.cs" />
     <Compile Include="IDiffResult.cs" />
+    <Compile Include="Core\Opaques.cs" />
+    <Compile Include="Core\Handles\TreeEntryOwnedHandle.cs" />
   </ItemGroup>
   <ItemGroup>
     <CodeAnalysisDictionary Include="CustomDictionary.xml" />
diff --git a/LibGit2Sharp/Tree.cs b/LibGit2Sharp/Tree.cs
@@ -47,24 +47,24 @@ public virtual TreeEntry this[string relativePath]
             get { return RetrieveFromPath(relativePath); }
         }
 
-        private TreeEntry RetrieveFromPath(FilePath relativePath)
+        private unsafe TreeEntry RetrieveFromPath(FilePath relativePath)
         {
             if (relativePath.IsNullOrEmpty())
             {
                 return null;
             }
 
-            using (TreeEntrySafeHandle_Owned treeEntryPtr = Proxy.git_tree_entry_bypath(repo.Handle, Id, relativePath))
+            using (TreeEntryOwnedHandle treeEntry = Proxy.git_tree_entry_bypath(repo.Handle, Id, relativePath))
             {
-                if (treeEntryPtr == null)
+                if (treeEntry == null)
                 {
                     return null;
                 }
 
                 string posixPath = relativePath.Posix;
                 string filename = posixPath.Split('/').Last();
                 string parentPath = posixPath.Substring(0, posixPath.Length - filename.Length);
-                return new TreeEntry(treeEntryPtr, Id, repo, path.Combine(parentPath));
+                return new TreeEntry(treeEntry.Handle, Id, repo, path.Combine(parentPath));
             }
         }
 
@@ -75,6 +75,11 @@ internal string Path
 
         #region IEnumerable<TreeEntry> Members
 
+        unsafe TreeEntry byIndex(ObjectSafeWrapper obj, uint i, ObjectId parentTreeId, Repository repo, FilePath parentPath)
+        {
+            return new TreeEntry(Proxy.git_tree_entry_byindex(obj.ObjectPtr, i), parentTreeId, repo, parentPath);
+        }
+
         /// <summary>
         /// Returns an enumerator that iterates through the collection.
         /// </summary>
@@ -83,10 +88,8 @@ public virtual IEnumerator<TreeEntry> GetEnumerator()
         {
             using (var obj = new ObjectSafeWrapper(Id, repo.Handle))
             {
-                for (uint i = 0; i < Count; i++)
-                {
-                    TreeEntrySafeHandle handle = Proxy.git_tree_entry_byindex(obj.ObjectPtr, i);
-                    yield return new TreeEntry(handle, Id, repo, path);
+                for (uint i = 0; i < Count; i++) {
+                    yield return byIndex(obj, i, Id, repo, path);
                 }
             }
         }
diff --git a/LibGit2Sharp/TreeEntry.cs b/LibGit2Sharp/TreeEntry.cs
@@ -27,19 +27,19 @@ public class TreeEntry : IEquatable<TreeEntry>
         protected TreeEntry()
         { }
 
-        internal TreeEntry(SafeHandle obj, ObjectId parentTreeId, Repository repo, FilePath parentPath)
+        internal unsafe TreeEntry(git_tree_entry* entry, ObjectId parentTreeId, Repository repo, FilePath parentPath)
         {
             this.parentTreeId = parentTreeId;
             this.repo = repo;
-            targetOid = Proxy.git_tree_entry_id(obj);
+            targetOid = Proxy.git_tree_entry_id(entry);
 
-            GitObjectType treeEntryTargetType = Proxy.git_tree_entry_type(obj);
+            GitObjectType treeEntryTargetType = Proxy.git_tree_entry_type(entry);
             TargetType = treeEntryTargetType.ToTreeEntryTargetType();
 
             target = new Lazy<GitObject>(RetrieveTreeEntryTarget);
 
-            Mode = Proxy.git_tree_entry_attributes(obj);
-            Name = Proxy.git_tree_entry_name(obj);
+            Mode = Proxy.git_tree_entry_attributes(entry);
+            Name = Proxy.git_tree_entry_name(entry);
             path = new Lazy<string>(() => System.IO.Path.Combine(parentPath.Native, Name));
         }
 

Original file line number	Diff line number	Diff line change
`@@ -3156,21 +3156,21 @@ public static void git_transport_unregister(String prefix)`
`3156`	`3156`
`3157`	`3157`	`#region git_tree_`
`3158`	`3158`
`3159`		`- public static Mode git_tree_entry_attributes(SafeHandle entry)`
	`3159`	`+ public static unsafe Mode git_tree_entry_attributes(git_tree_entry* entry)`
`3160`	`3160`	`{`
`3161`	`3161`	`return (Mode)NativeMethods.git_tree_entry_filemode(entry);`
`3162`	`3162`	`}`
`3163`	`3163`
`3164`		`- public static TreeEntrySafeHandle git_tree_entry_byindex(GitObjectSafeHandle tree, long idx)`
	`3164`	`+ public static unsafe git_tree_entry* git_tree_entry_byindex(GitObjectSafeHandle tree, long idx)`
`3165`	`3165`	`{`
`3166`	`3166`	`return NativeMethods.git_tree_entry_byindex(tree, (UIntPtr)idx);`
`3167`	`3167`	`}`
`3168`	`3168`
`3169`		`- public static TreeEntrySafeHandle_Owned git_tree_entry_bypath(RepositorySafeHandle repo, ObjectId id, FilePath treeentry_path)`
	`3169`	`+ public static unsafe TreeEntryOwnedHandle git_tree_entry_bypath(RepositorySafeHandle repo, ObjectId id, FilePath treeentry_path)`
`3170`	`3170`	`{`
`3171`	`3171`	`using (var obj = new ObjectSafeWrapper(id, repo))`
`3172`	`3172`	`{`
`3173`		`- TreeEntrySafeHandle_Owned treeEntryPtr;`
	`3173`	`+ git_tree_entry* treeEntryPtr;`
`3174`	`3174`	`int res = NativeMethods.git_tree_entry_bypath(out treeEntryPtr, obj.ObjectPtr, treeentry_path);`
`3175`	`3175`
`3176`	`3176`	`if (res == (int)GitErrorCode.NotFound)`
`@@ -3180,26 +3180,26 @@ public static TreeEntrySafeHandle_Owned git_tree_entry_bypath(RepositorySafeHand`
`3180`	`3180`
`3181`	`3181`	`Ensure.ZeroResult(res);`
`3182`	`3182`
`3183`		`- return treeEntryPtr;`
	`3183`	`+ return new TreeEntryOwnedHandle(treeEntryPtr);`
`3184`	`3184`	`}`
`3185`	`3185`	`}`
`3186`	`3186`
`3187`		`- public static void git_tree_entry_free(IntPtr treeEntry)`
	`3187`	`+ public static unsafe void git_tree_entry_free(git_tree_entry* treeEntry)`
`3188`	`3188`	`{`
`3189`	`3189`	`NativeMethods.git_tree_entry_free(treeEntry);`
`3190`	`3190`	`}`
`3191`	`3191`
`3192`		`- public static ObjectId git_tree_entry_id(SafeHandle entry)`
	`3192`	`+ public static unsafe ObjectId git_tree_entry_id(git_tree_entry* entry)`
`3193`	`3193`	`{`
`3194`	`3194`	`return NativeMethods.git_tree_entry_id(entry).MarshalAsObjectId();`
`3195`	`3195`	`}`
`3196`	`3196`
`3197`		`- public static string git_tree_entry_name(SafeHandle entry)`
	`3197`	`+ public static unsafe string git_tree_entry_name(git_tree_entry* entry)`
`3198`	`3198`	`{`
`3199`	`3199`	`return NativeMethods.git_tree_entry_name(entry);`
`3200`	`3200`	`}`
`3201`	`3201`
`3202`		`- public static GitObjectType git_tree_entry_type(SafeHandle entry)`
	`3202`	`+ public static unsafe GitObjectType git_tree_entry_type(git_tree_entry* entry)`
`3203`	`3203`	`{`
`3204`	`3204`	`return NativeMethods.git_tree_entry_type(entry);`
`3205`	`3205`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,24 +47,24 @@ public virtual TreeEntry this[string relativePath]`
`47`	`47`	`get { return RetrieveFromPath(relativePath); }`
`48`	`48`	`}`
`49`	`49`
`50`		`- private TreeEntry RetrieveFromPath(FilePath relativePath)`
	`50`	`+ private unsafe TreeEntry RetrieveFromPath(FilePath relativePath)`
`51`	`51`	`{`
`52`	`52`	`if (relativePath.IsNullOrEmpty())`
`53`	`53`	`{`
`54`	`54`	`return null;`
`55`	`55`	`}`
`56`	`56`
`57`		`- using (TreeEntrySafeHandle_Owned treeEntryPtr = Proxy.git_tree_entry_bypath(repo.Handle, Id, relativePath))`
	`57`	`+ using (TreeEntryOwnedHandle treeEntry = Proxy.git_tree_entry_bypath(repo.Handle, Id, relativePath))`
`58`	`58`	`{`
`59`		`- if (treeEntryPtr == null)`
	`59`	`+ if (treeEntry == null)`
`60`	`60`	`{`
`61`	`61`	`return null;`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`string posixPath = relativePath.Posix;`
`65`	`65`	`string filename = posixPath.Split('/').Last();`
`66`	`66`	`string parentPath = posixPath.Substring(0, posixPath.Length - filename.Length);`
`67`		`- return new TreeEntry(treeEntryPtr, Id, repo, path.Combine(parentPath));`
	`67`	`+ return new TreeEntry(treeEntry.Handle, Id, repo, path.Combine(parentPath));`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
`@@ -75,6 +75,11 @@ internal string Path`
`75`	`75`
`76`	`76`	`#region IEnumerable<TreeEntry> Members`
`77`	`77`
	`78`	`+ unsafe TreeEntry byIndex(ObjectSafeWrapper obj, uint i, ObjectId parentTreeId, Repository repo, FilePath parentPath)`
	`79`	`+ {`
	`80`	`+ return new TreeEntry(Proxy.git_tree_entry_byindex(obj.ObjectPtr, i), parentTreeId, repo, parentPath);`
	`81`	`+ }`
	`82`	`+`
`78`	`83`	`/// <summary>`
`79`	`84`	`/// Returns an enumerator that iterates through the collection.`
`80`	`85`	`/// </summary>`
`@@ -83,10 +88,8 @@ public virtual IEnumerator<TreeEntry> GetEnumerator()`
`83`	`88`	`{`
`84`	`89`	`using (var obj = new ObjectSafeWrapper(Id, repo.Handle))`
`85`	`90`	`{`
`86`		`- for (uint i = 0; i < Count; i++)`
`87`		`- {`
`88`		`- TreeEntrySafeHandle handle = Proxy.git_tree_entry_byindex(obj.ObjectPtr, i);`
`89`		`- yield return new TreeEntry(handle, Id, repo, path);`
	`91`	`+ for (uint i = 0; i < Count; i++) {`
	`92`	`+ yield return byIndex(obj, i, Id, repo, path);`
`90`	`93`	`}`
`91`	`94`	`}`
`92`	`95`	`}`