null ref serialization helpers

Author: lucasteles

src/Backdash/Data/ObjectPool.cs

@@ -66,4 +66,14 @@ public void Return(T value)
         items.Push(value);
         set.Add(value);
     }
+
+    public void Clear()
+    {
+        numItems = 0;
+        fastItem = null;
+        items.Clear();
+        set.Clear();
+    }
+
+    public int Count => numItems + (fastItem is null ? 0 : 1);
 }

src/Backdash/Network/Messages/KeepAlive.cs

@@ -2,5 +2,5 @@
 
 namespace Backdash.Network.Messages;
 
-[Serializable, StructLayout(LayoutKind.Sequential)]
+[Serializable, StructLayout(LayoutKind.Sequential, Size = 1)]
 readonly record struct KeepAlive;

src/Backdash/Serialization/BinaryBufferReader.cs

@@ -365,6 +365,34 @@ public void ReadNumber<T>(ref T? value, bool isUnsigned) where T : unmanaged, IB
         return value;
     }
 
+    /// <summary>Reads a nullable <see cref="IBinarySerializable"/> <paramref name="value"/> from buffer.</summary>
+    /// <typeparam name="T">A nullable reference type that implements <see cref="IBinarySerializable"/>.</typeparam>
+    public void ReadNullable<T>(ref T? value, IObjectPool<T> pool, bool forceReturn = true)
+        where T : class, IBinarySerializable
+    {
+        if (ReadBoolean())
+        {
+            if (forceReturn)
+            {
+                if (value is not null)
+                    pool.Return(value);
+
+                value = pool.Rent();
+            }
+            else
+                value ??= pool.Rent();
+
+            Read(value);
+        }
+        else
+            value = null;
+    }
+
+    /// <summary>Reads a nullable <see cref="IBinarySerializable"/> <paramref name="value"/> from buffer.</summary>
+    /// <typeparam name="T">A nullable reference type that implements <see cref="IBinarySerializable"/>.</typeparam>
+    public void ReadNullable<T>(ref T? value, bool forceReturn = true) where T : class, IBinarySerializable, new() =>
+        ReadNullable(ref value, DefaultObjectPool<T>.Instance, forceReturn);
+
     /// <summary>Reads a <see cref="IBinarySerializable"/> <paramref name="value"/> from buffer.</summary>
     /// <typeparam name="T">A value type that implements <see cref="IBinarySerializable"/>.</typeparam>
     public void Read<T>(ref T value) where T : struct, IBinarySerializable => value.Deserialize(in this);
@@ -417,9 +445,20 @@ public void Read<T>(in CircularBuffer<T> values) where T : IBinarySerializable
     }
 
     /// <summary>Reads a <see cref="IBinarySerializable"/> <paramref name="value"/> from buffer.</summary>
-    /// <typeparam name="T">A reference value type that implements <see cref="IBinarySerializable"/>.</typeparam>
+    /// <typeparam name="T">A reference type that implements <see cref="IBinarySerializable"/>.</typeparam>
     public void Read<T>(T value) where T : class, IBinarySerializable => value.Deserialize(in this);
 
+    /// <inheritdoc cref="Read{T}(T)"/>
+    public void Read<T>(
+        ref T? value, bool nullable, bool forceReturn = true
+    ) where T : class, IBinarySerializable, new()
+    {
+        if (nullable)
+            ReadNullable(ref value, forceReturn);
+        else
+            Read(value!);
+    }
+
     /// <summary>Reads a span of <see cref="IBinarySerializable"/> <paramref name="values"/> into buffer.</summary>
     /// <typeparam name="T">A list of a reference type that implements <see cref="IBinarySerializable"/>.</typeparam>
     public void Read<T>(in Span<T> values, in IObjectPool<T> pool) where T : class, IBinarySerializable

src/Backdash/Serialization/BinaryBufferWriter.cs

@@ -530,6 +530,18 @@ public void Write<T>(ref readonly T? value) where T : struct, IBinarySerializabl
     /// <typeparam name="T">A type that implements <see cref="IBinarySerializable"/>.</typeparam>
     public void Write<T>(T value) where T : class, IBinarySerializable => value.Serialize(in this);
 
+    /// <summary>Writes a <see cref="IBinarySerializable"/> <paramref name="value"/> into buffer.</summary>
+    /// <typeparam name="T">A type that implements <see cref="IBinarySerializable"/>.</typeparam>
+    /// <param name="value">Value to be written</param>
+    /// <param name="nullable">If true write as nullable reference type.</param>
+    public void Write<T>(T? value, bool nullable) where T : class, IBinarySerializable
+    {
+        if (nullable)
+            WriteNullable(value);
+        else
+            Write(value!);
+    }
+
     /// <summary>Writes span of <see cref="IBinarySerializable"/> <paramref name="values"/> into buffer.</summary>
     /// <typeparam name="T">A type that implements <see cref="IBinarySerializable"/>.</typeparam>
     public void Write<T>(in ReadOnlySpan<T> values) where T : IBinarySerializable
@@ -573,6 +585,19 @@ public void Write(in StringBuilder value)
         value.CopyTo(0, AllocSpan<char>(len), len);
     }
 
+    /// <summary>Writes a maybe null <see cref="IBinarySerializable"/> <paramref name="value"/> into buffer.</summary>
+    /// <typeparam name="T">A nullable reference type that implements <see cref="IBinarySerializable"/>.</typeparam>
+    public void WriteNullable<T>(T? value) where T : class, IBinarySerializable
+    {
+        if (value is null)
+            Write(false);
+        else
+        {
+            Write(true);
+            Write(value);
+        }
+    }
+
     /// <summary>Writes an unmanaged struct into buffer.</summary>
     public void WriteStruct<T>(in T value) where T : unmanaged => Write(Mem.AsBytes(in value));
 

tests/Backdash.Tests/Specs/Unit/Serialization/BinaryBufferReadWriteValueTests.cs

@@ -7,6 +7,7 @@
 using Backdash.Serialization.Numerics;
 using Backdash.Tests.TestUtils;
 using Backdash.Tests.TestUtils.Types;
+using Microsoft.FSharp.Core;
 
 // ReSharper disable CompareOfFloatsByEqualityOperator
 #pragma warning disable S1244
@@ -402,6 +403,101 @@ public bool SerializableObject(SimpleRefData value, SimpleRefData result, Endian
         return value == result;
     }
 
+    static DefaultObjectPool<SimpleRefData> DataPool =>
+        (DefaultObjectPool<SimpleRefData>)DefaultObjectPool<SimpleRefData>.Instance;
+
+    [PropertyTest]
+    public bool SerializableNullableObjectToObject(
+        FSharpOption<SimpleRefData> valueOpt,
+        SimpleRefData? result,
+        Endianness endianness,
+        bool forceReturn
+    )
+    {
+        SimpleRefData? value = OptionModule.ToObj(valueOpt);
+
+        var size = Setup<SimpleStructData>(endianness, out var writer);
+        var expectedSize = (value is null ? 0 : size) + 1;
+
+        writer.Write(value, nullable: true);
+        writer.WrittenCount.Should().Be(expectedSize);
+
+        var reader = GetReader(writer);
+        reader.Read(ref result, nullable: true, forceReturn);
+        reader.ReadCount.Should().Be(expectedSize);
+
+        return value == result;
+    }
+
+    [PropertyTest]
+    public bool SerializableNullableObjectToNullRef(
+        FSharpOption<SimpleRefData> valueOpt,
+        Endianness endianness,
+        bool forceReturn
+    )
+    {
+        SimpleRefData? value = OptionModule.ToObj(valueOpt);
+        SimpleRefData? result = null;
+
+        DataPool.Clear();
+        var size = Setup<SimpleStructData>(endianness, out var writer);
+        var expectedSize = (value is null ? 0 : size) + 1;
+
+        writer.Write(value, nullable: true);
+        writer.WrittenCount.Should().Be(expectedSize);
+
+        var reader = GetReader(writer);
+        reader.Read(ref result, nullable: true, forceReturn);
+        reader.ReadCount.Should().Be(expectedSize);
+
+        DataPool.Count.Should().Be(0);
+        return value == result;
+    }
+
+    [PropertyTest]
+    public bool SerializableNullableObjectShouldUsePool(
+        FSharpOption<SimpleRefData> valueOpt,
+        SimpleRefData? result,
+        Endianness endianness,
+        bool forceReturn
+    )
+    {
+        DataPool.Clear();
+        DataPool.Return(DataPool.Rent());
+        SimpleRefData? value = OptionModule.ToObj(valueOpt);
+
+        Setup<SimpleStructData>(endianness, out var writer);
+        writer.Write(value, nullable: true);
+
+        var reader = GetReader(writer);
+        reader.Read(ref result, nullable: true, forceReturn);
+
+        if (forceReturn)
+            DataPool.Count.Should().Be(1);
+
+        return value == result;
+    }
+
+    [PropertyTest]
+    public bool SerializableNullableObject(
+        FSharpOption<SimpleRefData> valueOpt,
+        FSharpOption<SimpleRefData> resultOpt,
+        bool useNullable,
+        Endianness endianness
+    )
+    {
+        SimpleRefData? value = OptionModule.ToObj(valueOpt);
+        SimpleRefData? result = OptionModule.ToObj(resultOpt);
+        var withNullable = value is null || result is null || useNullable;
+        Setup<SimpleStructData>(endianness, out var writer);
+        writer.Write(value, nullable: withNullable);
+        var reader = GetReader(writer);
+        reader.Read(ref result, nullable: withNullable);
+
+        return value == result;
+    }
+
+
     [Collection(SerialCollectionDefinition.Name)]
     public class BinaryIntegerTests
     {