feat: FilterMemory serialization behavior is supported #17

Author: vla

src/BloomFilter/AsyncLock.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BloomFilter;
+
+/// <summary>
+/// AsyncLock
+/// </summary>
+internal readonly struct AsyncLock : IDisposable
+{
+    private readonly SemaphoreSlim _semaphore;
+    private readonly Releaser _releaser;
+    private readonly Task<Releaser> _releaserTask;
+
+    public int MaxCount { get; }
+
+    public AsyncLock() : this(1)
+    {
+    }
+
+    public AsyncLock(int maxCount = 1)
+    {
+        MaxCount = maxCount;
+        _semaphore = new SemaphoreSlim(maxCount);
+        _releaser = new Releaser(_semaphore);
+        _releaserTask = Task.FromResult(_releaser);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Releaser Acquire()
+    {
+        _semaphore.Wait();
+        return _releaser;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Task<Releaser> AcquireAsync(bool continueOnCapturedContext = false)
+    {
+        var acquireAsync = _semaphore.WaitAsync();
+        return Return(acquireAsync, continueOnCapturedContext);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Dispose() => _semaphore.Dispose();
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private Task<Releaser> Return(Task acquireAsync, bool continueOnCapturedContext)
+    {
+        return acquireAsync.Status == TaskStatus.RanToCompletion
+            ? _releaserTask
+            : WaitForAcquireAsync(acquireAsync, continueOnCapturedContext);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private async Task<Releaser> WaitForAcquireAsync(Task acquireAsync, bool continueOnCapturedContext)
+    {
+        await acquireAsync.ConfigureAwait(continueOnCapturedContext);
+        return _releaser;
+    }
+
+    public readonly struct Releaser(SemaphoreSlim? semaphore) : IDisposable
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Dispose() => semaphore?.Release();
+    }
+
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int GetRemainingCount()
+    {
+        return MaxCount - _semaphore.CurrentCount;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int GetCurrentCount()
+    {
+        return _semaphore.CurrentCount;
+    }
+}

src/BloomFilter/Configurations/FilterMemoryOptionsExtension.cs

@@ -1,27 +1,41 @@
-using Microsoft.Extensions.DependencyInjection;
+using System;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 
 namespace BloomFilter.Configurations;
 
 public class FilterMemoryOptionsExtension : IBloomFilterOptionsExtension
 {
     private readonly FilterMemoryOptions _options;
+    private readonly Type? _serializerType;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="FilterMemoryOptionsExtension"/> class.
     /// </summary>
     /// <param name="options">Configure.</param>
-    public FilterMemoryOptionsExtension(FilterMemoryOptions options)
+    /// <param name="serializerType"></param>
+    public FilterMemoryOptionsExtension(FilterMemoryOptions options, Type? serializerType = null)
     {
         _options = options;
+        _serializerType = serializerType;
     }
 
     public void AddServices(IServiceCollection services)
     {
         services.TryAddSingleton<IBloomFilterFactory, DefaultBloomFilterFactory>();
+
+        if (_serializerType is null)
+        {
+            services.TryAddSingleton<IFilterMemorySerializer, DefaultFilterMemorySerializer>();
+        }
+        else
+        {
+            services.TryAddSingleton(typeof(IFilterMemorySerializer), _serializerType);
+        }
+
         services.AddSingleton<IBloomFilter, FilterMemory>(x =>
         {
-            return new FilterMemory(_options);
+            return new FilterMemory(_options, x.GetRequiredService<IFilterMemorySerializer>());
         });
     }
 }

src/BloomFilter/DefaultFilterMemorySerializer.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BloomFilter;
+
+public class DefaultFilterMemorySerializer : IFilterMemorySerializer
+{
+    public async ValueTask SerializeAsync(FilterMemorySerializerParam param, Stream stream)
+    {
+        byte[] nameBytes = Encoding.UTF8.GetBytes(param.Name ?? string.Empty);
+        await stream.WriteAsync(BitConverter.GetBytes(nameBytes.Length), 0, 4);
+        await stream.WriteAsync(nameBytes, 0, nameBytes.Length);
+
+        await stream.WriteAsync(BitConverter.GetBytes(param.ExpectedElements), 0, 8);
+        await stream.WriteAsync(BitConverter.GetBytes(param.ErrorRate), 0, 8);
+        await stream.WriteAsync(BitConverter.GetBytes((int)param.Method), 0, 4);
+
+        await stream.WriteAsync(BitConverter.GetBytes(param.Buckets.Length), 0, 4);
+        foreach (var bucket in param.Buckets)
+        {
+            byte[] bucketBytes = new byte[bucket.Length / 8 + Mod(bucket.Length)];
+            bucket.CopyTo(bucketBytes, 0);
+            await stream.WriteAsync(BitConverter.GetBytes(bucketBytes.Length), 0, 4).ConfigureAwait(false);
+            await stream.WriteAsync(bucketBytes, 0, bucketBytes.Length).ConfigureAwait(false);
+        }
+    }
+
+    public async ValueTask<FilterMemorySerializerParam> DeserializeAsync(Stream stream)
+    {
+        var param = new FilterMemorySerializerParam();
+
+        byte[] lengthBytes = new byte[4];
+        byte[] int64Bytes = new byte[8];
+
+        await ReadExactlyAsync(stream, lengthBytes);
+        int nameLength = BitConverter.ToInt32(lengthBytes, 0);
+
+        byte[] nameBytes = new byte[nameLength];
+        await ReadExactlyAsync(stream, nameBytes);
+        param.Name = Encoding.UTF8.GetString(nameBytes);
+
+        await ReadExactlyAsync(stream, int64Bytes);
+        param.ExpectedElements = BitConverter.ToInt64(int64Bytes, 0);
+
+        await ReadExactlyAsync(stream, int64Bytes);
+        param.ErrorRate = BitConverter.ToDouble(int64Bytes, 0);
+
+        await ReadExactlyAsync(stream, lengthBytes);
+        param.Method = (HashMethod)BitConverter.ToInt32(lengthBytes, 0);
+
+        await ReadExactlyAsync(stream, lengthBytes);
+        int bucketsLength = BitConverter.ToInt32(lengthBytes, 0);
+        param.Buckets = new BitArray[bucketsLength];
+
+        for (int i = 0; i < bucketsLength; i++)
+        {
+            await ReadExactlyAsync(stream, lengthBytes);
+            int bitArrayLength = BitConverter.ToInt32(lengthBytes, 0);
+
+            byte[] bucketBytes = new byte[bitArrayLength];
+            await ReadExactlyAsync(stream, bucketBytes);
+
+            param.Buckets[i] = new BitArray(bucketBytes);
+        }
+
+        return param;
+    }
+
+    private async Task ReadExactlyAsync(Stream stream, byte[] data)
+    {
+#if NET7_0_OR_GREATER
+        await stream.ReadExactlyAsync(data, 0, data.Length).ConfigureAwait(false);
+#else
+        await stream.ReadAsync(data, 0, data.Length).ConfigureAwait(false);
+#endif
+    }
+
+    private int Mod(int len) => len % 8 > 0 ? 1 : 0;
+}

src/BloomFilter/Filter.cs

@@ -21,27 +21,27 @@ public abstract class Filter : IBloomFilter
     /// <summary>
     /// <see cref="HashFunction"/>
     /// </summary>
-    public HashFunction Hash { get; }
+    public HashFunction Hash { get; private set; }
 
     /// <summary>
     /// the Capacity of the Bloom filter
     /// </summary>
-    public long Capacity { get; }
+    public long Capacity { get; private set; }
 
     /// <summary>
     /// number of hash functions
     /// </summary>
-    public int Hashes { get; }
+    public int Hashes { get; private set; }
 
     /// <summary>
     ///  the expected elements.
     /// </summary>
-    public long ExpectedElements { get; }
+    public long ExpectedElements { get; private set; }
 
     /// <summary>
     /// the number of expected elements
     /// </summary>
-    public double ErrorRate { get; }
+    public double ErrorRate { get; private set; }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Filter"/> class.
@@ -101,6 +101,21 @@ public Filter(string name, long capacity, int hashes, HashFunction hashFunction)
         ErrorRate = BestP(hashes, capacity, ExpectedElements);
     }
 
+    protected void SetFilterParam(long expectedElements, double errorRate, HashMethod method)
+    {
+        if (expectedElements < 1)
+            throw new ArgumentOutOfRangeException("expectedElements", expectedElements, "expectedElements must be > 0");
+        if (errorRate >= 1 || errorRate <= 0)
+            throw new ArgumentOutOfRangeException("errorRate", errorRate, string.Format("errorRate must be between 0 and 1, exclusive. Was {0}", errorRate));
+
+        ExpectedElements = expectedElements;
+        ErrorRate = errorRate;
+        Hash = HashFunction.Functions[method];
+
+        Capacity = BestM(expectedElements, errorRate);
+        Hashes = BestK(expectedElements, Capacity);
+    }
+
     /// <summary>
     /// Adds the passed value to the filter.
     /// </summary>

src/BloomFilter/FilterBuilder.cs

@@ -14,7 +14,18 @@ public partial class FilterBuilder
     /// <returns></returns>
     public static IBloomFilter Build(FilterMemoryOptions options)
     {
-        return new FilterMemory(options);
+        return new FilterMemory(options, new DefaultFilterMemorySerializer());
+    }
+
+    /// <summary>
+    /// Creates a BloomFilter for the specified expected element
+    /// </summary>
+    /// <param name="options"><see cref="FilterMemoryOptions"/></param>
+    /// <param name="filterMemorySerializer"><see cref="IFilterMemorySerializer"/></param>
+    /// <returns></returns>
+    public static IBloomFilter Build(FilterMemoryOptions options, IFilterMemorySerializer filterMemorySerializer)
+    {
+        return new FilterMemory(options, filterMemorySerializer);
     }
 
     /// <summary>
@@ -71,10 +82,11 @@ public static IBloomFilter Build(long expectedElements, double errorRate, string
     /// <param name="errorRate">The error rate.</param>
     /// <param name="hashMethod">The hash method.</param>
     /// <param name="name"></param>
+    /// <param name="filterMemorySerializer"></param>
     /// <returns></returns>
-    public static IBloomFilter Build(long expectedElements, double errorRate, HashMethod hashMethod, string name = BloomFilterConstValue.DefaultInMemoryName)
+    public static IBloomFilter Build(long expectedElements, double errorRate, HashMethod hashMethod, string name = BloomFilterConstValue.DefaultInMemoryName, IFilterMemorySerializer? filterMemorySerializer = null)
     {
-        return new FilterMemory(name, expectedElements, errorRate, HashFunction.Functions[hashMethod]);
+        return new FilterMemory(name, expectedElements, errorRate, HashFunction.Functions[hashMethod], filterMemorySerializer ?? new DefaultFilterMemorySerializer());
     }
 
     /// <summary>
@@ -84,9 +96,10 @@ public static IBloomFilter Build(long expectedElements, double errorRate, HashMe
     /// <param name="errorRate">The error rate.</param>
     /// <param name="hashFunction">The hash function.</param>
     /// <param name="name"></param>
+    /// <param name="filterMemorySerializer"></param>
     /// <returns></returns>
-    public static IBloomFilter Build(long expectedElements, double errorRate, HashFunction hashFunction, string name = BloomFilterConstValue.DefaultInMemoryName)
+    public static IBloomFilter Build(long expectedElements, double errorRate, HashFunction hashFunction, string name = BloomFilterConstValue.DefaultInMemoryName, IFilterMemorySerializer? filterMemorySerializer = null)
     {
-        return new FilterMemory(name, expectedElements, errorRate, hashFunction);
+        return new FilterMemory(name, expectedElements, errorRate, hashFunction, filterMemorySerializer ?? new DefaultFilterMemorySerializer());
     }
 }