git_strarray marshaling improvements

LibGit2Sharp/Core/GitCheckoutOpts.cs

@@ -138,7 +138,7 @@ internal struct GitCheckoutOpts
         public progress_cb progress_cb;
         public IntPtr progress_payload;
 
-        public GitStrArrayIn paths;
+        public GitStrArray paths;
 
         public IntPtr baseline;
         public IntPtr target_directory;

LibGit2Sharp/Core/GitCheckoutOptsWrapper.cs

@@ -22,7 +22,7 @@ public GitCheckoutOptsWrapper(IConvertableToGitCheckoutOpts options, FilePath[]
 
             if (paths != null)
             {
-                PathArray = GitStrArrayIn.BuildFrom(paths);
+                PathArray = GitStrArrayManaged.BuildFrom(paths);
             }
 
             Options = new GitCheckoutOpts
@@ -32,7 +32,7 @@ public GitCheckoutOptsWrapper(IConvertableToGitCheckoutOpts options, FilePath[]
                 progress_cb = Callbacks.CheckoutProgressCallback,
                 notify_cb = Callbacks.CheckoutNotifyCallback,
                 notify_flags = options.CheckoutNotifyFlags,
-                paths = PathArray,
+                paths = PathArray.Array,
             };
         }
 
@@ -50,23 +50,11 @@ public GitCheckoutOptsWrapper(IConvertableToGitCheckoutOpts options, FilePath[]
         /// <summary>
         /// Keep the paths around so we can dispose them.
         /// </summary>
-        private GitStrArrayIn PathArray;
+        private GitStrArrayManaged PathArray;
 
         public void Dispose()
         {
-            Dispose(true);
-        }
-
-        private void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                if (PathArray != null)
-                {
-                    PathArray.Dispose();
-                    PathArray = null;
-                }
-            }
+            PathArray.Dispose();
         }
 
         /// <summary>

LibGit2Sharp/Core/GitDiff.cs

@@ -189,7 +189,7 @@ internal class GitDiffOptions : IDisposable
         /* options controlling which files are in the diff */
 
         public SubmoduleIgnore IgnoreSubmodules;
-        public GitStrArrayIn PathSpec;
+        public GitStrArrayManaged PathSpec;
         public diff_notify_cb NotifyCallback;
         public IntPtr NotifyPayload;
 
@@ -204,11 +204,6 @@ internal class GitDiffOptions : IDisposable
 
         public void Dispose()
         {
-            if (PathSpec == null)
-            {
-                return;
-            }
-
             PathSpec.Dispose();
         }
     }

LibGit2Sharp/Core/GitStatusOptions.cs

@@ -14,15 +14,10 @@ internal class GitStatusOptions : IDisposable
         public GitStatusShow Show;
         public GitStatusOptionFlags Flags;
 
-        GitStrArrayIn PathSpec;
+        GitStrArrayManaged PathSpec;
 
         public void Dispose()
         {
-            if (PathSpec == null)
-            {
-                return;
-            }
-
             PathSpec.Dispose();
         }
     }

LibGit2Sharp/Core/GitStrArray.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace LibGit2Sharp.Core
+{
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct GitStrArray
+    {
+        /// <summary>
+        /// A pointer to an array of null-terminated strings.
+        /// </summary>
+        public IntPtr Strings;
+
+        /// <summary>
+        /// The number of strings in the array.
+        /// </summary>
+        public UIntPtr Count;
+
+        /// <summary>
+        /// Resets the GitStrArray to default values.
+        /// </summary>
+        public void Reset()
+        {
+            Strings = IntPtr.Zero;
+            Count = UIntPtr.Zero;
+        }
+    }
+}

LibGit2Sharp/Core/GitStrArrayManaged.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace LibGit2Sharp.Core
+{
+    /// <summary>
+    /// A git_strarray where the string array and strings themselves were allocated
+    /// with LibGit2Sharp's allocator (Marshal.AllocHGlobal).
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct GitStrArrayManaged : IDisposable
+    {
+        public GitStrArray Array;
+
+        public static GitStrArrayManaged BuildFrom(string[] strings)
+        {
+            return BuildFrom(strings, StrictUtf8Marshaler.FromManaged);
+        }
+
+        public static GitStrArrayManaged BuildFrom(FilePath[] paths)
+        {
+            return BuildFrom(paths, StrictFilePathMarshaler.FromManaged);
+        }
+
+        private static GitStrArrayManaged BuildFrom<T>(T[] input, Func<T, IntPtr> marshaler)
+        {
+            var pointers = new IntPtr[input.Length];
+
+            for (int i = 0; i < input.Length; i++)
+            {
+                var item = input[i];
+                pointers[i] = marshaler(item);
+            }
+
+            var toReturn = new GitStrArrayManaged();
+
+            toReturn.Array.Strings = Marshal.AllocHGlobal(checked(IntPtr.Size * input.Length));
+            Marshal.Copy(pointers, 0, toReturn.Array.Strings, input.Length);
+            toReturn.Array.Count = new UIntPtr((uint)input.Length);
+
+            return toReturn;
+        }
+
+        public void Dispose()
+        {
+            var count = checked((int)Array.Count.ToUInt32());
+
+            for (int i = 0; i < count; i++)
+            {
+                EncodingMarshaler.Cleanup(Marshal.ReadIntPtr(Array.Strings, i * IntPtr.Size));
+            }
+
+            if (Array.Strings != IntPtr.Zero)
+            {
+                Marshal.FreeHGlobal(Array.Strings);
+            }
+
+            // Now that we've freed the memory, zero out the structure.
+            Array.Reset();
+        }
+    }
+}

LibGit2Sharp/Core/GitStrArrayNative.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace LibGit2Sharp.Core
+{
+    /// <summary>
+    /// A git_strarray where the string array and strings themselves were allocated
+    /// with libgit2's allocator. Only libgit2 can free this git_strarray.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct GitStrArrayNative : IDisposable
+    {
+        public GitStrArray Array;
+
+        /// <summary>
+        /// Enumerates each string from the array using the UTF-8 marshaler.
+        /// </summary>
+        public String[] ReadStrings()
+        {
+            var count = checked((int)Array.Count.ToUInt32());
+
+            String[] toReturn = new String[count];
+
+            for (int i = 0; i < count; i++)
+            {
+                toReturn[i] = LaxUtf8Marshaler.FromNative(Marshal.ReadIntPtr(Array.Strings, i * IntPtr.Size));
+            }
+
+            return toReturn;
+        }
+
+        public void Dispose()
+        {
+            if (Array.Strings != IntPtr.Zero)
+            {
+                NativeMethods.git_strarray_free(ref Array);
+            }
+
+            // Now that we've freed the memory, zero out the structure.
+            Array.Reset();
+        }
+    }
+}