Create handles via templating

We cannot create libgit2 wrapper objects which are generic over the
pointer types, so let's use a template instead. We map the C name to the
C# name and generate the same code for each of them.

Author: carlosmn

LibGit2Sharp/Core/Handles/Objects.cs

@@ -0,0 +1,42 @@
+
+using System;
+
+namespace LibGit2Sharp.Core
+{
+
+    internal unsafe class TreeEntryHandle : IDisposable
+    {
+        internal git_tree_entry* Handle { get; private set; }
+        bool owned;
+        bool disposed;
+
+        public unsafe TreeEntryHandle(git_tree_entry* handle, bool owned)
+        {
+            this.Handle = handle;
+            this.owned = owned;
+        }
+
+        ~TreeEntryHandle()
+        {
+            Dispose(false);
+        }
+
+        void Dispose(bool disposing)
+        {
+            if (!disposed)
+            {
+                if (owned)
+                {
+                    NativeMethods.git_tree_entry_free(Handle);
+                }
+            }
+
+            disposed = true;
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+    }
+}

LibGit2Sharp/Core/Handles/Objects.tt

@@ -0,0 +1,63 @@
+<#@ template language="C#" #>
+<#@ output extention=".cs" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+
+using System;
+
+namespace LibGit2Sharp.Core
+{
+
+<#
+var cNames = new[] {
+    "git_tree_entry",
+};
+
+var csNames = new[] {
+    "TreeEntryHandle"
+};
+
+for (var i = 0; i < cNames.Length; i++)
+{
+#>
+    internal unsafe class <#= csNames[i] #> : IDisposable
+    {
+        internal <#= cNames[i] #>* Handle { get; private set; }
+        bool owned;
+        bool disposed;
+
+        public unsafe <#= csNames[i] #>(<#= cNames[i] #>* handle, bool owned)
+        {
+            this.Handle = handle;
+            this.owned = owned;
+        }
+
+        ~<#= csNames[i] #>()
+        {
+            Dispose(false);
+        }
+
+        void Dispose(bool disposing)
+        {
+            if (!disposed)
+            {
+                if (owned)
+                {
+                    NativeMethods.<#= cNames[i] #>_free(Handle);
+                }
+            }
+
+            disposed = true;
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+    }
+<#
+}
+#>
+}

LibGit2Sharp/Core/Handles/TreeEntryOwnedHandle.cs

@@ -3159,12 +3159,18 @@ public static unsafe Mode git_tree_entry_attributes(git_tree_entry* entry)
             return (Mode)NativeMethods.git_tree_entry_filemode(entry);
         }
 
-        public static unsafe git_tree_entry* git_tree_entry_byindex(GitObjectSafeHandle tree, long idx)
+        public static unsafe TreeEntryHandle git_tree_entry_byindex(GitObjectSafeHandle tree, long idx)
         {
-            return NativeMethods.git_tree_entry_byindex(tree, (UIntPtr)idx);
+            var handle = NativeMethods.git_tree_entry_byindex(tree, (UIntPtr)idx);
+            if (handle == null)
+            {
+                return null;
+            }
+
+            return new TreeEntryHandle(handle, false);
         }
 
-        public static unsafe TreeEntryOwnedHandle git_tree_entry_bypath(RepositorySafeHandle repo, ObjectId id, FilePath treeentry_path)
+        public static unsafe TreeEntryHandle git_tree_entry_bypath(RepositorySafeHandle repo, ObjectId id, FilePath treeentry_path)
         {
             using (var obj = new ObjectSafeWrapper(id, repo))
             {
@@ -3178,15 +3184,10 @@ public static unsafe TreeEntryOwnedHandle git_tree_entry_bypath(RepositorySafeHa
 
                 Ensure.ZeroResult(res);
 
-                return new TreeEntryOwnedHandle(treeEntryPtr);
+                return new TreeEntryHandle(treeEntryPtr, true);
             }
         }
 
-        public static unsafe void git_tree_entry_free(git_tree_entry* treeEntry)
-        {
-            NativeMethods.git_tree_entry_free(treeEntry);
-        }
-
         public static unsafe ObjectId git_tree_entry_id(git_tree_entry* entry)
         {
             return NativeMethods.git_tree_entry_id(entry).MarshalAsObjectId();

LibGit2Sharp/Core/Proxy.cs

@@ -379,7 +379,9 @@
     <Compile Include="CertificateSsh.cs" />
     <Compile Include="IDiffResult.cs" />
     <Compile Include="Core\Opaques.cs" />
-    <Compile Include="Core\Handles\TreeEntryOwnedHandle.cs" />
+    <Compile Include="Core\Handles\Objects.cs">
+      <DependentUpon>Objects.tt</DependentUpon>
+    </Compile>
   </ItemGroup>
   <ItemGroup>
     <CodeAnalysisDictionary Include="CustomDictionary.xml" />
@@ -389,6 +391,10 @@
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
+    <None Include="Core\Handles\Objects.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>Objects.cs</LastGenOutput>
+    </None>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="UniqueIdentifier.targets" />

LibGit2Sharp/LibGit2Sharp.csproj

@@ -54,7 +54,7 @@ private unsafe TreeEntry RetrieveFromPath(FilePath relativePath)
                 return null;
             }
 
-            using (TreeEntryOwnedHandle treeEntry = Proxy.git_tree_entry_bypath(repo.Handle, Id, relativePath))
+            using (TreeEntryHandle treeEntry = Proxy.git_tree_entry_bypath(repo.Handle, Id, relativePath))
             {
                 if (treeEntry == null)
                 {
@@ -64,7 +64,7 @@ private unsafe TreeEntry RetrieveFromPath(FilePath relativePath)
                 string posixPath = relativePath.Posix;
                 string filename = posixPath.Split('/').Last();
                 string parentPath = posixPath.Substring(0, posixPath.Length - filename.Length);
-                return new TreeEntry(treeEntry.Handle, Id, repo, path.Combine(parentPath));
+                return new TreeEntry(treeEntry, Id, repo, path.Combine(parentPath));
             }
         }
 

LibGit2Sharp/Tree.cs

@@ -27,8 +27,9 @@ public class TreeEntry : IEquatable<TreeEntry>
         protected TreeEntry()
         { }
 
-        internal unsafe TreeEntry(git_tree_entry* entry, ObjectId parentTreeId, Repository repo, FilePath parentPath)
+        internal unsafe TreeEntry(TreeEntryHandle handle, ObjectId parentTreeId, Repository repo, FilePath parentPath)
         {
+            var entry = handle.Handle;
             this.parentTreeId = parentTreeId;
             this.repo = repo;
             targetOid = Proxy.git_tree_entry_id(entry);