Merge pull request #1247

Bring back some pointers

Author: Edward Thomson

LibGit2Sharp.Tests/RefSpecFixture.cs

@@ -105,8 +105,10 @@ public void RemoteUpdaterSavesRefSpecsPermanently()
 
             using (var repo = new Repository(path))
             {
-                var remote = repo.Network.Remotes["origin"];
-                repo.Network.Remotes.Update(remote, r => r.FetchRefSpecs = fetchRefSpecs);
+                using (var remote = repo.Network.Remotes["origin"])
+                {
+                    repo.Network.Remotes.Update(remote, r => r.FetchRefSpecs = fetchRefSpecs);
+                }
             }
 
             using (var repo = new Repository(path))
@@ -127,22 +129,23 @@ public void CanAddAndRemoveRefSpecs()
             var path = SandboxStandardTestRepo();
 
             using (var repo = new Repository(path))
+            using (var remote = repo.Network.Remotes["origin"])
             {
-                var remote = repo.Network.Remotes["origin"];
-
-                remote = repo.Network.Remotes.Update(remote,
+                using (var updatedRemote = repo.Network.Remotes.Update(remote,
                     r => r.FetchRefSpecs.Add(newRefSpec),
-                    r => r.PushRefSpecs.Add(newRefSpec));
-
-                Assert.Contains(newRefSpec, remote.FetchRefSpecs.Select(r => r.Specification));
-                Assert.Contains(newRefSpec, remote.PushRefSpecs.Select(r => r.Specification));
-
-                remote = repo.Network.Remotes.Update(remote,
-                    r => r.FetchRefSpecs.Remove(newRefSpec),
-                    r => r.PushRefSpecs.Remove(newRefSpec));
-
-                Assert.DoesNotContain(newRefSpec, remote.FetchRefSpecs.Select(r => r.Specification));
-                Assert.DoesNotContain(newRefSpec, remote.PushRefSpecs.Select(r => r.Specification));
+                    r => r.PushRefSpecs.Add(newRefSpec)))
+                {
+                    Assert.Contains(newRefSpec, updatedRemote.FetchRefSpecs.Select(r => r.Specification));
+                    Assert.Contains(newRefSpec, updatedRemote.PushRefSpecs.Select(r => r.Specification));
+
+                    using (var updatedRemote2 = repo.Network.Remotes.Update(updatedRemote,
+                        r => r.FetchRefSpecs.Remove(newRefSpec),
+                        r => r.PushRefSpecs.Remove(newRefSpec)))
+                    {
+                        Assert.DoesNotContain(newRefSpec, updatedRemote2.FetchRefSpecs.Select(r => r.Specification));
+                        Assert.DoesNotContain(newRefSpec, updatedRemote2.PushRefSpecs.Select(r => r.Specification));
+                    }
+                }
             }
         }
 

LibGit2Sharp.Tests/TestHelpers/BaseFixture.cs

@@ -263,7 +263,7 @@ public virtual void Dispose()
             if (LeaksContainer.TypeNames.Any())
             {
                 Assert.False(true, string.Format("Some handles of the following types haven't been properly released: {0}.{1}"
-                    + "In order to get some help fixing those leaks, uncomment the define LEAKS_TRACKING in SafeHandleBase.cs{1}"
+                    + "In order to get some help fixing those leaks, uncomment the define LEAKS_TRACKING in Libgit2Object.cs{1}"
                     + "and run the tests locally.", string.Join(", ", LeaksContainer.TypeNames), Environment.NewLine));
             }
 #endif

LibGit2Sharp/BlameHunk.cs

@@ -19,31 +19,35 @@ public class BlameHunk : IEquatable<BlameHunk>
                                                 x => x.InitialSignature,
                                                 x => x.InitialCommit);
 
-
-        internal BlameHunk(IRepository repository, GitBlameHunk rawHunk)
+        internal unsafe BlameHunk(IRepository repository, git_blame_hunk* rawHunk)
         {
-            finalCommit = new Lazy<Commit>(() => repository.Lookup<Commit>(rawHunk.FinalCommitId));
-            origCommit = new Lazy<Commit>(() => repository.Lookup<Commit>(rawHunk.OrigCommitId));
+            var origId = ObjectId.BuildFromPtr(&rawHunk->orig_commit_id);
+            var finalId = ObjectId.BuildFromPtr(&rawHunk->final_commit_id);
+
+            finalCommit = new Lazy<Commit>(() => repository.Lookup<Commit>(finalId));
+            origCommit = new Lazy<Commit>(() => repository.Lookup<Commit>(origId));
 
-            if (rawHunk.OrigPath != IntPtr.Zero)
+
+            if (rawHunk->orig_path != null)
             {
-                InitialPath = LaxUtf8Marshaler.FromNative(rawHunk.OrigPath);
+                InitialPath = LaxUtf8Marshaler.FromNative(rawHunk->orig_path);
             }
-            LineCount = rawHunk.LinesInHunk.ConvertToInt();
+
+            LineCount = (int)rawHunk->lines_in_hunk.ToUInt32();
 
             // Libgit2's line numbers are 1-based
-            FinalStartLineNumber = rawHunk.FinalStartLineNumber.ConvertToInt() - 1;
-            InitialStartLineNumber = rawHunk.OrigStartLineNumber.ConvertToInt() - 1;
+            FinalStartLineNumber = (int)rawHunk->final_start_line_number.ToUInt32() - 1;
+            InitialStartLineNumber = (int)rawHunk->orig_start_line_number.ToUInt32() - 1;
 
             // Signature objects need to have ownership of their native pointers
-            if (rawHunk.FinalSignature != IntPtr.Zero)
+            if (rawHunk->final_signature != null)
             {
-                FinalSignature = new Signature(Proxy.git_signature_dup(rawHunk.FinalSignature));
+                FinalSignature = new Signature(rawHunk->final_signature);
             }
 
-            if (rawHunk.OrigSignature != IntPtr.Zero)
+            if (rawHunk->orig_signature != null)
             {
-                InitialSignature = new Signature(Proxy.git_signature_dup(rawHunk.OrigSignature));
+                InitialSignature = new Signature(rawHunk->orig_signature);
             }
         }
 

LibGit2Sharp/BlameHunkCollection.cs

@@ -2,6 +2,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.InteropServices;
 using LibGit2Sharp.Core;
 using LibGit2Sharp.Core.Handles;
 
@@ -20,26 +21,32 @@ public class BlameHunkCollection : IEnumerable<BlameHunk>
         /// </summary>
         protected BlameHunkCollection() { }
 
-        internal BlameHunkCollection(Repository repo, RepositorySafeHandle repoHandle, string path, BlameOptions options)
+        internal unsafe BlameHunkCollection(Repository repo, RepositoryHandle repoHandle, string path, BlameOptions options)
         {
             this.repo = repo;
 
-            var rawopts = new GitBlameOptions
+            var rawopts = new git_blame_options
             {
                 version = 1,
                 flags = options.Strategy.ToGitBlameOptionFlags(),
-                MinLine = new UIntPtr((uint)options.MinLine),
-                MaxLine = new UIntPtr((uint)options.MaxLine),
+                min_line = new UIntPtr((uint)options.MinLine),
+                max_line = new UIntPtr((uint)options.MaxLine),
             };
 
             if (options.StartingAt != null)
             {
-                rawopts.NewestCommit = repo.Committish(options.StartingAt).Oid;
+                fixed (byte* p = rawopts.newest_commit.Id)
+                {
+                    Marshal.Copy(repo.Committish(options.StartingAt).Oid.Id, 0, new IntPtr(p), git_oid.Size);
+                }
             }
 
             if (options.StoppingAt != null)
             {
-                rawopts.OldestCommit = repo.Committish(options.StoppingAt).Oid;
+                fixed (byte* p = rawopts.oldest_commit.Id)
+                {
+                    Marshal.Copy(repo.Committish(options.StoppingAt).Oid.Id, 0, new IntPtr(p), git_oid.Size);
+                }
             }
 
             using (var blameHandle = Proxy.git_blame_file(repoHandle, path, rawopts))

LibGit2Sharp/BranchCollection.cs

@@ -199,7 +199,7 @@ public virtual void Remove(Branch branch)
         {
             Ensure.ArgumentNotNull(branch, "branch");
 
-            using (ReferenceSafeHandle referencePtr = repo.Refs.RetrieveReferencePtr(branch.CanonicalName))
+            using (ReferenceHandle referencePtr = repo.Refs.RetrieveReferencePtr(branch.CanonicalName))
             {
                 Proxy.git_branch_delete(referencePtr);
             }
@@ -267,7 +267,7 @@ public virtual Branch Rename(Branch branch, string newName, bool allowOverwrite)
                                                 branch.FriendlyName);
             }
 
-            using (ReferenceSafeHandle referencePtr = repo.Refs.RetrieveReferencePtr(Reference.LocalBranchPrefix + branch.FriendlyName))
+            using (ReferenceHandle referencePtr = repo.Refs.RetrieveReferencePtr(Reference.LocalBranchPrefix + branch.FriendlyName))
             {
                 using (Proxy.git_branch_move(referencePtr, newName, allowOverwrite))
                 { }

LibGit2Sharp/CertificateSsh.cs

@@ -1,6 +1,6 @@
-using LibGit2Sharp.Core;
-using System;
+using System;
 using System.Runtime.InteropServices;
+using LibGit2Sharp.Core;
 
 namespace LibGit2Sharp
 {
@@ -39,20 +39,32 @@ protected CertificateSsh()
         /// True if we have the SHA1 hostkey hash from the server
         /// </summary>public readonly bool HasSHA1;
 
-        internal CertificateSsh(GitCertificateSsh cert)
+        internal unsafe CertificateSsh(git_certificate_ssh* cert)
         {
 
-            HasMD5  = cert.type.HasFlag(GitCertificateSshType.MD5);
-            HasSHA1 = cert.type.HasFlag(GitCertificateSshType.SHA1);
+            HasMD5  = cert->type.HasFlag(GitCertificateSshType.MD5);
+            HasSHA1 = cert->type.HasFlag(GitCertificateSshType.SHA1);
 
             HashMD5 = new byte[16];
-            cert.HashMD5.CopyTo(HashMD5, 0);
+            fixed (byte* p = &HashMD5[0])
+            {
+                for (var i = 0; i < HashMD5.Length; i++)
+                {
+                    HashMD5[i] = p[i];
+                }
+            }
 
             HashSHA1 = new byte[20];
-            cert.HashSHA1.CopyTo(HashSHA1, 0);
+            fixed (byte* p = &HashSHA1[0])
+            {
+                for (var i = 0; i < HashSHA1.Length; i++)
+                {
+                    HashSHA1[i] = p[i];
+                }
+            }
         }
 
-        internal IntPtr ToPointer()
+        internal unsafe IntPtr ToPointer()
         {
             GitCertificateSshType sshCertType = 0;
             if (HasMD5)
@@ -64,13 +76,27 @@ internal IntPtr ToPointer()
                 sshCertType |= GitCertificateSshType.SHA1;
             }
 
-            var gitCert = new GitCertificateSsh
+            var gitCert = new git_certificate_ssh()
             {
                 cert_type = GitCertificateType.Hostkey,
                 type = sshCertType,
             };
-            HashMD5.CopyTo(gitCert.HashMD5, 0);
-            HashSHA1.CopyTo(gitCert.HashSHA1, 0);
+
+            fixed (byte *p = &HashMD5[0])
+            {
+                for (var i = 0; i < HashMD5.Length; i++)
+                {
+                    gitCert.HashMD5[i] = p[i];
+                }
+            }
+
+            fixed (byte *p = &HashSHA1[0])
+            {
+                for (var i = 0; i < HashSHA1.Length; i++)
+                {
+                    gitCert.HashSHA1[i] = p[i];
+                }
+            }
 
             var ptr = Marshal.AllocHGlobal(Marshal.SizeOf(gitCert));
             Marshal.StructureToPtr(gitCert, ptr, false);

LibGit2Sharp/CertificateX509.cs

@@ -22,23 +22,23 @@ protected CertificateX509()
         /// </summary>
         public virtual X509Certificate Certificate { get; private set; }
 
-        internal CertificateX509(GitCertificateX509 cert)
+        internal unsafe CertificateX509(git_certificate_x509* cert)
         {
-            int len = checked((int) cert.len.ToUInt32());
+            int len = checked((int) cert->len.ToUInt32());
             byte[] data = new byte[len];
-            Marshal.Copy(cert.data, data, 0, len);
+            Marshal.Copy(new IntPtr(cert->data), data, 0, len);
             Certificate = new X509Certificate(data);
         }
 
-        internal IntPtr ToPointers(out IntPtr dataPtr)
+        internal unsafe IntPtr ToPointers(out IntPtr dataPtr)
         {
             var certData = Certificate.Export(X509ContentType.Cert);
             dataPtr = Marshal.AllocHGlobal(certData.Length);
             Marshal.Copy(certData, 0, dataPtr, certData.Length);
-            var gitCert = new GitCertificateX509()
+            var gitCert = new git_certificate_x509()
             {
                 cert_type = GitCertificateType.X509,
-                data = dataPtr,
+                data = (byte*) dataPtr.ToPointer(),
                 len = (UIntPtr)certData.LongLength,
             };
 

LibGit2Sharp/Commit.cs

@@ -106,7 +106,7 @@ private IEnumerable<Note> RetrieveNotesOfCommit(ObjectId oid)
             return repo.Notes[oid];
         }
 
-        private static string RetrieveEncodingOf(GitObjectSafeHandle obj)
+        private static string RetrieveEncodingOf(ObjectHandle obj)
         {
             string encoding = Proxy.git_commit_message_encoding(obj);
 

LibGit2Sharp/CommitLog.cs

@@ -108,7 +108,7 @@ public IEnumerable<LogEntry> QueryBy(string path, FollowFilter filter)
         private class CommitEnumerator : IEnumerator<Commit>
         {
             private readonly Repository repo;
-            private readonly RevWalkerSafeHandle handle;
+            private readonly RevWalkerHandle handle;
             private ObjectId currentOid;
 
             public CommitEnumerator(Repository repo, CommitFilter filter)
@@ -167,7 +167,7 @@ private void Dispose(bool disposing)
                 handle.SafeDispose();
             }
 
-            private delegate void HidePushSignature(RevWalkerSafeHandle handle, ObjectId id);
+            private delegate void HidePushSignature(RevWalkerHandle handle, ObjectId id);
 
             private void InternalHidePush(IList<object> identifier, HidePushSignature hidePush)
             {