Add BlitPackFormatterAttribute

README.md

@@ -583,7 +583,7 @@ public partial class Employee
 
 CustomFormatter
 ---
-If implements `MemoryPackCustomFormatterAttribute<T>`, you can configure to use custom formatter to MemoryPackObject's member.
+If implements `MemoryPackCustomFormatterAttribute<T>` or `MemoryPackCustomFormatterAttribute<TFormatter, T>`(more performant but complex), you can configure to use custom formatter to MemoryPackObject's member.
 
 ```csharp
 [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
@@ -593,17 +593,23 @@ public abstract class MemoryPackCustomFormatterAttribute<T> : Attribute
 }
 ```
 
-In built-in attribtues, `Utf8StringFormatterAttribute`, `Utf16StringFormatterAttribute`, `OrdinalIgnoreCaseStringDictionaryFormatter<TValue>` exsits.
+In built-in attribtues, `Utf8StringFormatterAttribute`, `Utf16StringFormatterAttribute`, `InternStringFormatterAttribute`, `OrdinalIgnoreCaseStringDictionaryFormatterAttribtue<TValue>`, `BitPackFormatterAttribtue` exsits.
 
 ```csharp
 [MemoryPackable]
 public partial class Sample
 {
+    // serialize this member as UTF16 String, it is performant than UTF8 but in ASCII, size is larger(but non ASCII, sometimes smaller).
     [Utf16StringFormatter]
     public string? Text { get; set; }
 
+    // In deserialize, Dictionary is initialized with StringComparer.OrdinalIgnoreCase.
     [OrdinalIgnoreCaseStringDictionaryFormatter<int>]
     public Dictionary<string, int>? Ids { get; set; }
+
+    // In deserialize time, all string is interned(see: String.Intern). If similar values come repeatedly, it saves memory.
+    [InternStringFormatter]
+    public string? Flag { get; set; }
 }
 ```
 
@@ -621,6 +627,19 @@ public sealed class OrdinalIgnoreCaseStringDictionaryFormatter<TValue> : MemoryP
 }
 ```
 
+`BitPackFormatter` is for `bool[]`, same serialzied result as `BitArray`. In other words, bool is normally 1byte, but since it is treated as 1bit, eight bools are stored in one byte. Therefore, the size after serialization is 1/8.
+
+```csharp
+[MemoryPackable]
+public partial class Sample
+{
+    public int Id { get; set; }
+
+    [BitPackFormatter]
+    public bool[]? Data { get; set; }
+}
+```
+
 Performance
 ---
 TODO for describe details, stay tuned.

src/MemoryPack.Core/Compression/BitPackFormatter.cs

@@ -0,0 +1,110 @@
+using MemoryPack.Internal;
+using System.Runtime.CompilerServices;
+
+namespace MemoryPack.Compression;
+
+[Preserve]
+public sealed class BitPackFormatter : MemoryPackFormatter<bool[]>
+{
+    public static readonly BitPackFormatter Default = new BitPackFormatter();
+
+    [Preserve]
+    public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref bool[]? value)
+    {
+        if (value == null)
+        {
+            writer.WriteNullCollectionHeader();
+            return;
+        }
+        writer.WriteCollectionHeader(value.Length);
+
+        var data = 0;
+        var bit = 0;
+        foreach (var item in value)
+        {
+            Set(ref data, bit, item);
+
+            bit += 1;
+
+            if (bit == 32)
+            {
+                writer.WriteUnmanaged(data);
+                data = 0;
+                bit = 0;
+            }
+        }
+
+        if (bit != 0)
+        {
+            writer.WriteUnmanaged(data);
+        }
+    }
+
+    [Preserve]
+    public override void Deserialize(ref MemoryPackReader reader, scoped ref bool[]? value)
+    {
+        if (!reader.DangerousTryReadCollectionHeader(out var length))
+        {
+            value = null;
+            return;
+        }
+
+        if (length == 0)
+        {
+            value = Array.Empty<bool>();
+            return;
+        }
+
+        var readCount = ((length - 1) / 32) + 1;
+        var requireSize = readCount * 4;
+        if (reader.Remaining < requireSize)
+        {
+            MemoryPackSerializationException.ThrowInsufficientBufferUnless(length);
+        }
+
+        if (value == null || value.Length != length)
+        {
+            value = new bool[length];
+        }
+
+        var bit = 0;
+        var data = 0;
+        for (int i = 0; i < value.Length; i++)
+        {
+            if (bit == 0)
+            {
+                reader.ReadUnmanaged(out data);
+            }
+
+            value[i] = Get(data, bit);
+
+            bit += 1;
+
+            if (bit == 32)
+            {
+                data = 0;
+                bit = 0;
+            }
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool Get(int data, int index)
+    {
+        return (data & (1 << index)) != 0;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Set(ref int data, int index, bool value)
+    {
+        int bitMask = 1 << index;
+        if (value)
+        {
+            data |= bitMask;
+        }
+        else
+        {
+            data &= ~bitMask;
+        }
+    }
+}

src/MemoryPack.Core/CustomFormatterAttributes.cs

@@ -1,4 +1,5 @@
-using MemoryPack.Formatters;
+using MemoryPack.Compression;
+using MemoryPack.Formatters;
 
 namespace MemoryPack;
 
@@ -38,4 +39,12 @@ public override InternStringFormatter GetFormatter()
     }
 }
 
+public sealed class BitPackFormatterAttribute : MemoryPackCustomFormatterAttribute<BitPackFormatter, bool[]>
+{
+    public override BitPackFormatter GetFormatter()
+    {
+        return BitPackFormatter.Default;
+    }
+}
+
 #endif

src/MemoryPack.Core/MemoryPack.Core.csproj

@@ -74,6 +74,9 @@
     <ItemGroup>
         <TargetFiles1 Include="$(MSBuildProjectDirectory)\**\*.cs" Exclude="**\bin\**\*.*;**\obj\**\*.*;**\CompressedArray.cs;**\CollectionsMarshalEx.cs;**\ImmutableCollectionFormatters.cs" />
     </ItemGroup>
+    <ItemGroup>
+      <TargetFiles1 Remove="BitPackFormatter.cs" />
+    </ItemGroup>
 
     <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="$(TargetFramework) == 'net7.0'">
         <Copy SourceFiles="@(TargetFiles1)" DestinationFiles="$(DestinationRoot)\%(RecursiveDir)%(Filename)%(Extension)" SkipUnchangedFiles="true" />

src/MemoryPack.Unity/Assets/Plugins/MemoryPack/Runtime/MemoryPack.Core/Compression/BitPackFormatter.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+#nullable enable
+using MemoryPack.Internal;
+using System.Runtime.CompilerServices;
+
+namespace MemoryPack.Compression {
+
+[Preserve]
+public sealed class BitPackFormatter : MemoryPackFormatter<bool[]>
+{
+    public static readonly BitPackFormatter Default = new BitPackFormatter();
+
+    [Preserve]
+    public override void Serialize(ref MemoryPackWriter writer, ref bool[]? value)
+    {
+        if (value == null)
+        {
+            writer.WriteNullCollectionHeader();
+            return;
+        }
+        writer.WriteCollectionHeader(value.Length);
+
+        var data = 0;
+        var bit = 0;
+        foreach (var item in value)
+        {
+            Set(ref data, bit, item);
+
+            bit += 1;
+
+            if (bit == 32)
+            {
+                writer.WriteUnmanaged(data);
+                data = 0;
+                bit = 0;
+            }
+        }
+
+        if (bit != 0)
+        {
+            writer.WriteUnmanaged(data);
+        }
+    }
+
+    [Preserve]
+    public override void Deserialize(ref MemoryPackReader reader, ref bool[]? value)
+    {
+        if (!reader.DangerousTryReadCollectionHeader(out var length))
+        {
+            value = null;
+            return;
+        }
+
+        if (length == 0)
+        {
+            value = Array.Empty<bool>();
+            return;
+        }
+
+        var readCount = ((length - 1) / 32) + 1;
+        var requireSize = readCount * 4;
+        if (reader.Remaining < requireSize)
+        {
+            MemoryPackSerializationException.ThrowInsufficientBufferUnless(length);
+        }
+
+        if (value == null || value.Length != length)
+        {
+            value = new bool[length];
+        }
+
+        var bit = 0;
+        var data = 0;
+        for (int i = 0; i < value.Length; i++)
+        {
+            if (bit == 0)
+            {
+                reader.ReadUnmanaged(out data);
+            }
+
+            value[i] = Get(data, bit);
+
+            bit += 1;
+
+            if (bit == 32)
+            {
+                data = 0;
+                bit = 0;
+            }
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool Get(int data, int index)
+    {
+        return (data & (1 << index)) != 0;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Set(ref int data, int index, bool value)
+    {
+        int bitMask = 1 << index;
+        if (value)
+        {
+            data |= bitMask;
+        }
+        else
+        {
+            data &= ~bitMask;
+        }
+    }
+}
+
+}

src/MemoryPack.Unity/Assets/Plugins/MemoryPack/Runtime/MemoryPack.Core/CustomFormatterAttributes.cs

@@ -7,6 +7,7 @@
 using System.Threading.Tasks;
 
 #nullable enable
+using MemoryPack.Compression;
 using MemoryPack.Formatters;
 
 namespace MemoryPack {
@@ -47,6 +48,14 @@ public override InternStringFormatter GetFormatter()
     }
 }
 
+public sealed class BitPackFormatterAttribute : MemoryPackCustomFormatterAttribute<BitPackFormatter, bool[]>
+{
+    public override BitPackFormatter GetFormatter()
+    {
+        return BitPackFormatter.Default;
+    }
+}
+
 #endif
 
 }