BonSerialization of Dictionary

Author: Bobris

BTDB/Serialization/BonSerializer.cs

@@ -69,7 +69,10 @@ enum BonSerializerCmd : byte
     NextArray,
     InitList,
     InitHashSet,
-    NextHashSet
+    NextHashSet,
+    InitDictionary,
+    NextDictionary,
+    AddOffset
 }
 
 public ref struct BonSerializerCtx
@@ -267,6 +270,24 @@ public void Generate()
             return;
         }
 
+        if (_type.SpecializationOf(typeof(Dictionary<,>)) is { } dictionaryType)
+        {
+            _memWriter.WriteUInt8((byte)BonSerializerCmd.InitDictionary);
+            var keyType = dictionaryType.GetGenericArguments()[0];
+            var valueType = dictionaryType.GetGenericArguments()[1];
+            var layout = RawData.GetDictionaryEntriesLayout(keyType, valueType);
+            _memWriter.WriteUInt8((byte)BonSerializerCmd.AddOffset);
+            _memWriter.WriteVUInt32(layout.OffsetKey);
+            WriteCmdByType(null, keyType);
+            _memWriter.WriteUInt8((byte)BonSerializerCmd.AddOffset);
+            _memWriter.WriteVUInt32(layout.OffsetValue - layout.OffsetKey);
+            WriteCmdByType(null, valueType);
+            _memWriter.WriteUInt8((byte)BonSerializerCmd.AddOffset);
+            _memWriter.WriteVUInt32(layout.Size - layout.OffsetValue);
+            _memWriter.WriteUInt8((byte)BonSerializerCmd.NextDictionary);
+            return;
+        }
+
         var classMetadata = ReflectionMetadata.FindByType(_type);
         if (classMetadata != null)
         {
@@ -707,6 +728,55 @@ public unsafe BonSerialize Build()
 
                         break;
                     }
+                    case BonSerializerCmd.AddOffset:
+                        offset += reader.ReadVUInt32();
+                        break;
+                    case BonSerializerCmd.InitDictionary:
+                    {
+                        tempObject2 = Unsafe.As<byte, object>(ref value);
+                        var count = Unsafe.As<byte, int>(ref RawData.Ref(tempObject2,
+                            RawData.Align(8 + 6 * (uint)Unsafe.SizeOf<nint>(), 8)));
+                        tempObject2 = RawData.HashSetEntries(Unsafe.As<HashSet<object>>(tempObject2));
+                        ref readonly var mt = ref RawData.MethodTableRef(tempObject2);
+                        offset = mt.BaseSize - (uint)Unsafe.SizeOf<nint>();
+                        offsetDelta = mt.ComponentSize;
+                        offsetFinal = offset + offsetDelta * (uint)count;
+                        offsetLabel = (uint)reader.GetCurrentPositionWithoutController();
+                        ctx.Builder.StartDictionary();
+                        while (offset < offsetFinal)
+                        {
+                            if (Unsafe.As<byte, int>(ref RawData.Ref(tempObject2, offset + 4)) >= -1) break;
+                            offset += offsetDelta;
+                        }
+
+                        if (offset >= offsetFinal)
+                        {
+                            ctx.Builder.FinishDictionary();
+                            return;
+                        }
+
+                        break;
+                    }
+                    case BonSerializerCmd.NextDictionary:
+                    {
+                        while (offset < offsetFinal)
+                        {
+                            if (Unsafe.As<byte, int>(ref RawData.Ref(tempObject2, offset + 4)) >= -1) break;
+                            offset += offsetDelta;
+                        }
+
+                        if (offset < offsetFinal)
+                        {
+                            reader.SetCurrentPositionWithoutController(offsetLabel);
+                        }
+                        else
+                        {
+                            ctx.Builder.FinishDictionary();
+                            return;
+                        }
+
+                        break;
+                    }
                     default:
                         throw new InvalidDataException("Unknown command in BonSerializer " + (byte)cmd + " at " +
                                                        (reader.GetCurrentPosition() - 1));

BTDB/Serialization/RawData.cs

@@ -79,6 +79,16 @@ public static (uint Offset, uint Size) GetHashSetEntriesLayout(Type memberType)
         return (Align(8, sa.Align), sa.Size);
     }
 
+    public static (uint OffsetKey, uint OffsetValue, uint Size) GetDictionaryEntriesLayout(Type keyType, Type valueType)
+    {
+        var saKey = GetSizeAndAlign(keyType);
+        var saValue = GetSizeAndAlign(valueType);
+        var sa = Combine((8, 4), saKey, saValue);
+        var offsetKey = Align(8, sa.Align);
+        var offsetValue = Align(offsetKey + saKey.Size, saValue.Align);
+        return (offsetKey, offsetValue, sa.Size);
+    }
+
     public static uint CombineAlign(uint align1, uint align2)
     {
         return align1 > align2 ? align1 : align2;
@@ -127,6 +137,26 @@ public static (uint Size, uint Align) GetSizeAndAlign(Type type)
             return Combine(GetSizeAndAlign(arguments[0]), GetSizeAndAlign(arguments[1]), GetSizeAndAlign(arguments[2]));
         }
 
+        if (type == typeof(long) || type == typeof(ulong) || type == typeof(double))
+        {
+            return (8, 8);
+        }
+
+        if (type == typeof(int) || type == typeof(uint) || type == typeof(float))
+        {
+            return (4, 4);
+        }
+
+        if (type == typeof(short) || type == typeof(ushort) || type == typeof(char) || type == typeof(Half))
+        {
+            return (2, 2);
+        }
+
+        if (type == typeof(byte) || type == typeof(sbyte) || type == typeof(bool))
+        {
+            return (1, 1);
+        }
+
         var size = MethodTableOf(type).BaseSize;
         return (size, size);
     }

BTDBTest/SerializationTests/BonSerializerTest.SerializeDeserializeAllSupportedTypes.approved.txt

@@ -35,7 +35,8 @@
     "Self": null,
     "DoubleArray": null,
     "IntList": null,
-    "UShortSet": null
+    "UShortSet": null,
+    "LongIntDict": null
   },
   "DoubleArray": [
     2.718281828459045,
@@ -49,5 +50,15 @@
   "UShortSet": [
     666,
     12345
+  ],
+  "LongIntDict": [
+    [
+      1111,
+      2
+    ],
+    [
+      3333,
+      4
+    ]
   ]
 }

BTDBTest/SerializationTests/BonSerializerTest.cs

@@ -32,6 +32,7 @@ public class AllSupportedTypes
         public double[]? DoubleArray;
         public List<int>? IntList;
         public HashSet<ushort>? UShortSet;
+        public Dictionary<long, int>? LongIntDict;
     }
 
     [Fact]
@@ -44,7 +45,8 @@ public void SerializeDeserializeAllSupportedTypes()
             DateTime = new(2024, 2, 11, 14, 4, 30),
             Guid = Guid.Parse("9e251065-0873-49bc-8fd9-266cc9aa39d3"), Float16 = (Half)3.14, Float32 = 3.14f,
             Float64 = Math.PI,
-            Self = new(), DoubleArray = [Math.E, Math.PI], IntList = [1, 20, 300], UShortSet = [666, 12345]
+            Self = new(), DoubleArray = [Math.E, Math.PI], IntList = [1, 20, 300], UShortSet = [666, 12345],
+            LongIntDict = new() { { 1111, 2 }, { 3333, 4 } }
         };
         var builder = new BonBuilder();
         BonSerializerFactory.Serialize(ref builder, obj);