refactor Comparator

Author: warrenfalk

RocksDbSharp/ColumnFamilyOptions.cs

@@ -2,13 +2,16 @@
 using System.Collections.Generic;
 using System.Dynamic;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace RocksDbSharp
 {
     public class ColumnFamilyOptions : OptionsHandle
     {
+        Comparator Comparator { get; set; }
+        IntPtr ComparatorStatePtr { get; set; }
 
         public ColumnFamilyOptions SetBlockBasedTableFactory(BlockBasedTableOptions table_options)
         {
@@ -156,8 +159,63 @@ public ColumnFamilyOptions SetComparator(IntPtr comparator)
             return this;
         }
 
+        /// <summary>
+        /// Comparator used to define the order of keys in the table.
+        /// Default: a comparator that uses lexicographic byte-wise ordering
+        ///
+        /// REQUIRES: The client must ensure that the comparator supplied
+        /// here has the same name and orders keys *exactly* the same as the
+        /// comparator provided to previous open calls on the same DB.
+        /// </summary>
         public ColumnFamilyOptions SetComparator(Comparator comparator)
-            => SetComparator(comparator.Handle);
+        {
+            // Hold onto the reference to the comparator
+            Comparator = comparator;
+
+            // Allocate some memory for the name bytes
+            var name = comparator.Name ?? comparator.GetType().FullName;
+            var nameBytes = Encoding.UTF8.GetBytes(name + "\0");
+            var namePtr = Marshal.AllocHGlobal(nameBytes.Length);
+            Marshal.Copy(nameBytes, 0, namePtr, nameBytes.Length);
+
+            // Allocate the state
+            var state = new ComparatorState
+            {
+                NamePtr = namePtr,
+            };
+            var statePtr = Marshal.AllocHGlobal(Marshal.SizeOf(state));
+            Marshal.StructureToPtr(state, statePtr, false);
+
+            // Create the comparator
+            IntPtr handle = Native.Instance.rocksdb_comparator_create(
+                state: statePtr,
+                destructor: Comparator_Destroy,
+                compare: Comparator_Compare,
+                name: Comparator_GetNamePtr
+            );
+
+            ComparatorStatePtr = statePtr;
+
+            return SetComparator(handle);
+        }
+
+        private unsafe int Comparator_Compare(IntPtr state, IntPtr a, UIntPtr alen, IntPtr b, UIntPtr blen)
+            => Comparator.Compare(a, alen, b, blen);
+
+        private unsafe void Comparator_Destroy(IntPtr state)
+        {
+            var namePtr = (*((ComparatorState*)state)).NamePtr;
+            Marshal.FreeHGlobal(namePtr);
+            Marshal.FreeHGlobal(state);
+        }
+        private unsafe IntPtr Comparator_GetNamePtr(IntPtr state)
+            => (*((ComparatorState*)state)).NamePtr;
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct ComparatorState
+        {
+            public IntPtr NamePtr { get; set; }
+        }
 
         /// <summary>
         /// REQUIRES: The client must provide a merge operator if Merge operation

RocksDbSharp/Comparator.cs

@@ -6,72 +6,32 @@
 
 namespace RocksDbSharp
 {
-    public unsafe delegate int CompareFunc(IntPtr state, byte* a, ulong alen, byte* b, ulong blen);
-    public delegate void DestroyFunc(IntPtr state);
-    public delegate string GetNameFunc(IntPtr state);
-
     public interface Comparator
     {
-        IntPtr Handle { get; }
+        string Name { get; }
+        int Compare(IntPtr a, UIntPtr alen, IntPtr b, UIntPtr blen);
     }
 
-    public abstract class ComparatorBase : Comparator
-    {
-        public IntPtr Handle { get; protected set; }
-        public virtual string Name { get; }
-
-        private DestroyFunc _destroy;
-
-        public unsafe ComparatorBase(string name = null, IntPtr state = default(IntPtr))
-        {
-            Name = name ?? GetType().FullName;
-            _destroy = s => this.Destroy(s);
-            Handle = Native.Instance.rocksdb_comparator_create(
-                state: IntPtr.Zero,
-                destructor: CurrentFramework.GetFunctionPointerForDelegate(_destroy),
-                compare: CurrentFramework.GetFunctionPointerForDelegate<CompareFunc>(Compare),
-                getName: CurrentFramework.GetFunctionPointerForDelegate<GetNameFunc>(GetName)
-            );
-        }
-
-        ~ComparatorBase()
-        {
-            if (Handle != IntPtr.Zero)
-            {
-#if !NODESTROY
-                Native.Instance.rocksdb_comparator_destroy(Handle);
-#endif
-                Handle = IntPtr.Zero;
-            }
-        }
-
-        public abstract unsafe int Compare(IntPtr state, byte* a, ulong alen, byte* b, ulong blen);
-
-        public virtual void Destroy(IntPtr state)
-        {
-        }
-
-        protected virtual string GetName(IntPtr state) => Name;
-    }
-
-    public abstract class StringComparatorBase : ComparatorBase
+    public abstract class StringComparatorBase : Comparator
     {
         public Encoding Encoding { get; }
 
+        public string Name { get; }
+
         public StringComparatorBase(Encoding encoding = null, string name = null, IntPtr state = default(IntPtr))
-            : base(name, state)
         {
+            Name = name ?? typeof(StringComparatorBase).Name;
             Encoding = encoding ?? Encoding.UTF8;
         }
 
-        public override unsafe int Compare(IntPtr state, byte* a, ulong alen, byte* b, ulong blen)
+        public abstract int Compare(string a, string b);
+
+        public unsafe int Compare(IntPtr a, UIntPtr alen, IntPtr b, UIntPtr blen)
         {
-            var astr = Encoding.GetString(a, (int)alen);
-            var bstr = Encoding.GetString(b, (int)blen);
-            return Compare(state, astr, bstr);
+            var astr = Encoding.GetString((byte*)a, (int)alen);
+            var bstr = Encoding.GetString((byte*)b, (int)blen);
+            return Compare(astr, bstr);
         }
-
-        public abstract int Compare(IntPtr state, string a, string b);
     }
 
     public class StringComparator : StringComparatorBase
@@ -91,6 +51,6 @@ public StringComparator(bool ignoreCase, Encoding encoding = null, string name =
         {
         }
 
-        public override int Compare(IntPtr state, string a, string b) => CompareFunc(a, b);
+        public override int Compare(string a, string b) => CompareFunc(a, b);
     }
 }