improve single number serialization logic

Author: lucasteles

src/Backdash/Network/Protocol/Comm/ProtocolMessageSerializer.cs

@@ -1,24 +1,26 @@
 using Backdash.Network.Messages;
 using Backdash.Serialization;
+using Backdash.Serialization.Internal;
 
 namespace Backdash.Network.Protocol.Comm;
 
 sealed class ProtocolMessageSerializer(Endianness endianness) : IBinarySerializer<ProtocolMessage>
 {
+    readonly EndiannessSerializer.INumberSerializer numberSerializer = EndiannessSerializer.Get(endianness);
     public Endianness Endianness => endianness;
 
     public int Serialize(in ProtocolMessage data, Span<byte> buffer)
     {
         var offset = 0;
-        BinarySpanWriter writer = new(buffer, ref offset, endianness);
+        BinarySpanWriter writer = new(buffer, ref offset, numberSerializer);
         data.Serialize(in writer);
         return writer.WrittenCount;
     }
 
     public int Deserialize(ReadOnlySpan<byte> data, ref ProtocolMessage value)
     {
         var offset = 0;
-        BinaryBufferReader reader = new(data, ref offset, endianness);
+        BinaryBufferReader reader = new(data, ref offset, numberSerializer);
         value.Deserialize(in reader);
         return offset;
     }

src/Backdash/Options/NetcodeOptions.cs

@@ -1,5 +1,6 @@
 using Backdash.Network;
 using Backdash.Network.Client;
+using Backdash.Serialization.Internal;
 using Backdash.Synchronizing.State;
 
 namespace Backdash.Options;
@@ -45,6 +46,9 @@ public sealed record NetcodeOptions
     internal Endianness GetStateSerializationEndianness() =>
         StateSerializationEndianness ?? Protocol.SerializationEndianness;
 
+    internal EndiannessSerializer.INumberSerializer GetEndiannessNumberStateSerializer() =>
+        EndiannessSerializer.Get(GetStateSerializationEndianness());
+
     /// <summary>
     ///     Max length for player input queues.
     /// </summary>

src/Backdash/Options/ProtocolOptions.cs

@@ -22,7 +22,7 @@ public sealed record ProtocolOptions
     public int UdpPacketBufferSize { get; set; }
 
     /// <summary>
-    ///     Max allowed pending inputs in sending queue.
+    ///     Max allowed pending inputs in the sending queue.
     ///     When reached <see cref="INetcodeSession{TInput}.AddLocalInput(Backdash.NetcodePlayer, in TInput)" /> will return
     ///     <see cref="ResultCode.InputDropped" />.
     /// </summary>
@@ -31,7 +31,7 @@ public sealed record ProtocolOptions
 
     /// <summary>
     ///     Max allowed pending UDP output messages.
-    ///     When reached removes and ignores the oldest package in the queue in order to make room for the new package.
+    ///     When reached, removes and ignores the oldest package in the queue in order to make room for the new package.
     /// </summary>
     /// <value>Defaults to <c>64</c></value>
     public int MaxPackageQueue { get; set; } = 64;

src/Backdash/Serialization/BinaryBufferReader.cs

@@ -7,6 +7,7 @@
 using Backdash.Core;
 using Backdash.Data;
 using Backdash.Network;
+using Backdash.Serialization.Internal;
 
 namespace Backdash.Serialization;
 
@@ -16,24 +17,46 @@ namespace Backdash.Serialization;
 [DebuggerDisplay("Read: {ReadCount}")]
 public readonly ref struct BinaryBufferReader
 {
+    readonly ref int offset;
+    readonly ReadOnlySpan<byte> buffer;
+    readonly EndiannessSerializer.INumberSerializer numberSerializer;
+
     /// <summary>
     ///     Initialize a new <see cref="BinaryBufferReader" /> for <paramref name="buffer" />
     /// </summary>
     /// <param name="buffer">Byte buffer to be read</param>
     /// <param name="offset">Read offset reference</param>
-    /// <param name="endianness">Deserialization endianness</param>
-    public BinaryBufferReader(ReadOnlySpan<byte> buffer, ref int offset, Endianness? endianness = null)
+    /// <param name="numberSerializer">Number serializer instance</param>
+    public BinaryBufferReader(
+        ReadOnlySpan<byte> buffer, ref int offset,
+        EndiannessSerializer.INumberSerializer numberSerializer
+    )
     {
+        ArgumentNullException.ThrowIfNull(numberSerializer);
         this.offset = ref offset;
         this.buffer = buffer;
-        Endianness = endianness ?? Platform.Endianness;
+        this.numberSerializer = numberSerializer;
     }
 
-    readonly ref int offset;
-    readonly ReadOnlySpan<byte> buffer;
+    /// <summary>
+    ///     Initialize a new <see cref="BinaryBufferReader" /> for <paramref name="buffer" />
+    /// </summary>
+    /// <param name="buffer">Byte buffer to be read</param>
+    /// <param name="offset">Read offset reference</param>
+    /// <param name="endianness">Deserialization endianness</param>
+    public BinaryBufferReader(ReadOnlySpan<byte> buffer, ref int offset, Endianness endianness)
+        : this(buffer, ref offset, EndiannessSerializer.Get(endianness)) { }
+
+    /// <summary>
+    ///     Initialize a new <see cref="BinaryBufferReader" /> for <paramref name="buffer" />
+    /// </summary>
+    /// <param name="buffer">Byte buffer to be read</param>
+    /// <param name="offset">Read offset reference</param>
+    public BinaryBufferReader(ReadOnlySpan<byte> buffer, ref int offset)
+        : this(buffer, ref offset, Platform.Endianness) { }
 
-    /// <summary>Gets or init the value to define which endianness should be used for serialization.</summary>
-    public readonly Endianness Endianness;
+    /// <summary>Gets current serialization endianness.</summary>
+    public Endianness Endianness => numberSerializer.Endianness;
 
     /// <summary>Total read byte count.</summary>
     public int ReadCount => offset;
@@ -313,35 +336,16 @@ public void ReadUtf8String(in Span<char> values)
     /// <summary>Reads single <see cref="IBinaryInteger{T}" /> from buffer.</summary>
     /// <typeparam name="T">A numeric type that implements <see cref="IBinaryInteger{T}" />.</typeparam>
     /// <param name="isUnsigned">
-    ///     true if source represents an unsigned two's complement number; otherwise, false to indicate it
+    ///     true if value represents an unsigned two's complement number; otherwise, false to indicate it
     ///     represents a signed two's complement number
     /// </param>
     public T ReadNumber<T>(bool isUnsigned) where T : unmanaged, IBinaryInteger<T>
     {
-        var size = Unsafe.SizeOf<T>();
-        var result = Endianness switch
-        {
-            Endianness.LittleEndian => T.ReadLittleEndian(CurrentBuffer[..size], isUnsigned),
-            Endianness.BigEndian => T.ReadBigEndian(CurrentBuffer[..size], isUnsigned),
-            _ => default,
-        };
-        Advance(size);
+        var result = numberSerializer.Read<T>(CurrentBuffer, isUnsigned, out var written);
+        Advance(written);
         return result;
     }
 
-    /// <summary>Reads single <see cref="IBinaryInteger{T}" /> from buffer.</summary>
-    /// <typeparam name="T">A numeric type that implements <see cref="IBinaryInteger{T}" /> and <see cref="IMinMaxValue{T}" />.</typeparam>
-    public T ReadNumber<T>() where T : unmanaged, IBinaryInteger<T>, IMinMaxValue<T> =>
-        ReadNumber<T>(T.IsZero(T.MinValue));
-
-    /// <inheritdoc cref="ReadNumber{T}()" />
-    public void ReadNumber<T>(ref T value) where T : unmanaged, IBinaryInteger<T>, IMinMaxValue<T> =>
-        value = ReadNumber<T>();
-
-    /// <inheritdoc cref="ReadNullableNumber{T}()" />
-    public void ReadNumber<T>(ref T? value) where T : unmanaged, IBinaryInteger<T>, IMinMaxValue<T> =>
-        value = ReadNullableNumber<T>();
-
     /// <inheritdoc cref="ReadNumber{T}(bool)" />
     public void ReadNumber<T>(ref T value, bool isUnsigned) where T : unmanaged, IBinaryInteger<T> =>
         value = ReadNumber<T>(isUnsigned);
@@ -350,10 +354,6 @@ public void ReadNumber<T>(ref T value, bool isUnsigned) where T : unmanaged, IBi
     public void ReadNumber<T>(ref T? value, bool isUnsigned) where T : unmanaged, IBinaryInteger<T> =>
         value = ReadNullableNumber<T>(isUnsigned);
 
-    /// <inheritdoc cref="ReadNumber{T}()" />
-    public T? ReadNullableNumber<T>() where T : unmanaged, IBinaryInteger<T>, IMinMaxValue<T> =>
-        ReadBoolean() ? ReadNumber<T>() : null;
-
     /// <inheritdoc cref="ReadNumber{T}(bool)" />
     public T? ReadNullableNumber<T>(bool isUnsigned) where T : unmanaged, IBinaryInteger<T> =>
         ReadBoolean() ? ReadNumber<T>(isUnsigned) : null;

src/Backdash/Serialization/BinaryBufferWriter.cs

@@ -8,6 +8,7 @@
 using Backdash.Core;
 using Backdash.Data;
 using Backdash.Network;
+using Backdash.Serialization.Internal;
 
 namespace Backdash.Serialization;
 
@@ -18,14 +19,27 @@ namespace Backdash.Serialization;
 ///     Initialize a new <see cref="BinaryBufferWriter" /> for <paramref name="buffer" />
 /// </remarks>
 /// <param name="buffer">Byte buffer to be written</param>
-/// <param name="endianness">Serialization endianness</param>
+/// <param name="numberSerializer">Number serializer instance</param>
 [DebuggerDisplay("Written: {WrittenCount}")]
-public readonly struct BinaryBufferWriter(ArrayBufferWriter<byte> buffer, Endianness? endianness = null)
+public readonly struct BinaryBufferWriter(
+    ArrayBufferWriter<byte> buffer,
+    EndiannessSerializer.INumberSerializer numberSerializer
+)
 {
     /// <summary>
-    ///     Gets or init the value to define which endianness should be used for serialization.
+    ///    Instantiate a new binary span writer.
     /// </summary>
-    public readonly Endianness Endianness = endianness ?? Platform.Endianness;
+    /// <param name="buffer">Byte buffer to be written</param>
+    /// <param name="endianness">Serialization endianness</param>
+    public BinaryBufferWriter(ArrayBufferWriter<byte> buffer, Endianness endianness) : this(buffer,
+        EndiannessSerializer.Get(endianness))
+    { }
+
+    /// <inheritdoc cref="BinaryBufferWriter(System.Buffers.ArrayBufferWriter{byte},Backdash.Network.Endianness)"/>
+    public BinaryBufferWriter(ArrayBufferWriter<byte> buffer) : this(buffer, Platform.Endianness) { }
+
+    /// <summary>Gets current serialization endianness.</summary>
+    public Endianness Endianness => numberSerializer.Endianness;
 
     /// <summary>
     ///     Backing IBufferWriter <see cref="IBufferWriter{T}" />
@@ -660,20 +674,7 @@ public void WriteUtf8String(in ReadOnlySpan<char> value)
     /// <typeparam name="T">A numeric type that implements <see cref="IBinaryInteger{T}" />.</typeparam>
     public void WriteNumber<T>(in T value) where T : unmanaged, IBinaryInteger<T>
     {
-        ref var valueRef = ref Unsafe.AsRef(in value);
-        var size = Unsafe.SizeOf<T>();
-        switch (Endianness)
-        {
-            case Endianness.LittleEndian:
-                valueRef.TryWriteLittleEndian(buffer.GetSpan(size), out size);
-                break;
-            case Endianness.BigEndian:
-                valueRef.TryWriteBigEndian(buffer.GetSpan(size), out size);
-                break;
-            default:
-                return;
-        }
-
+        numberSerializer.Write(buffer, in value, out var size);
         Advance(size);
     }
 

src/Backdash/Serialization/BinarySerializerExtensions.cs

@@ -0,0 +1,68 @@
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace Backdash.Serialization;
+
+/// <summary>
+/// Signed number extensions
+/// </summary>
+public static class BinarySerializerSignedExtensions
+{
+    const bool IsUnsigned = false;
+
+    /// <inheritdoc cref="BinaryBufferReader.ReadNumber{T}(bool)"/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static T ReadNumber<T>(ref readonly this BinaryBufferReader reader)
+        where T : unmanaged, IBinaryInteger<T>, ISignedNumber<T> =>
+        reader.ReadNumber<T>(IsUnsigned);
+
+    /// <inheritdoc cref="BinaryBufferReader.ReadNumber{T}(ref T, bool)"/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void ReadNumber<T>(ref readonly this BinaryBufferReader reader, ref T value)
+        where T : unmanaged, IBinaryInteger<T>, ISignedNumber<T> =>
+        reader.ReadNumber(ref value, IsUnsigned);
+
+    /// <inheritdoc cref="BinaryBufferReader.ReadNumber{T}( ref T?, bool)"/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void ReadNumber<T>(ref readonly this BinaryBufferReader reader, ref T? value)
+        where T : unmanaged, IBinaryInteger<T>, ISignedNumber<T> =>
+        reader.ReadNumber(ref value, IsUnsigned);
+
+    /// <inheritdoc cref="BinaryBufferReader.ReadNullableNumber{T}(bool)"/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static T? ReadNullableNumber<T>(ref readonly this BinaryBufferReader reader)
+        where T : unmanaged, IBinaryInteger<T>, ISignedNumber<T> =>
+        reader.ReadNullableNumber<T>(IsUnsigned);
+}
+
+/// <summary>
+/// Unsigned number extensions
+/// </summary>
+public static class BinarySerializerUnsignedExtensions
+{
+    const bool IsUnsigned = true;
+
+    /// <inheritdoc cref="BinaryBufferReader.ReadNumber{T}(bool)"/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static T ReadNumber<T>(ref readonly this BinaryBufferReader reader)
+        where T : unmanaged, IBinaryInteger<T>, ISignedNumber<T> =>
+        reader.ReadNumber<T>(IsUnsigned);
+
+    /// <inheritdoc cref="BinaryBufferReader.ReadNumber{T}(ref T, bool)"/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void ReadNumber<T>(ref readonly this BinaryBufferReader reader, ref T value)
+        where T : unmanaged, IBinaryInteger<T>, ISignedNumber<T> =>
+        reader.ReadNumber(ref value, IsUnsigned);
+
+    /// <inheritdoc cref="BinaryBufferReader.ReadNumber{T}( ref T?, bool)"/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void ReadNumber<T>(ref readonly this BinaryBufferReader reader, ref T? value)
+        where T : unmanaged, IBinaryInteger<T>, ISignedNumber<T> =>
+        reader.ReadNumber(ref value, IsUnsigned);
+
+    /// <inheritdoc cref="BinaryBufferReader.ReadNullableNumber{T}(bool)"/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static T? ReadNullableNumber<T>(ref readonly this BinaryBufferReader reader)
+        where T : unmanaged, IBinaryInteger<T>, ISignedNumber<T> =>
+        reader.ReadNullableNumber<T>(IsUnsigned);
+}

src/Backdash/Serialization/BinarySpanWriter.cs

@@ -5,6 +5,7 @@
 using System.Runtime.InteropServices;
 using Backdash.Core;
 using Backdash.Network;
+using Backdash.Serialization.Internal;
 
 namespace Backdash.Serialization;
 
@@ -14,28 +15,47 @@ namespace Backdash.Serialization;
 [DebuggerDisplay("Written: {WrittenCount}")]
 public readonly ref struct BinarySpanWriter
 {
+    readonly ref int offset;
+    readonly Span<byte> buffer;
+    readonly EndiannessSerializer.INumberSerializer numberSerializer;
+
     /// <summary>
     ///     Initialize a new <see cref="BinarySpanWriter" /> for <paramref name="buffer" />
     /// </summary>
     /// <param name="buffer">Byte buffer to be written</param>
     /// <param name="offset">Write offset reference</param>
-    /// <param name="endianness">Serialization endianness</param>
+    /// <param name="numberSerializer">Number serializer instance</param>
     public BinarySpanWriter(
         scoped in Span<byte> buffer,
         ref int offset,
-        Endianness? endianness = null
+        EndiannessSerializer.INumberSerializer numberSerializer
     )
     {
+        ArgumentNullException.ThrowIfNull(numberSerializer);
         this.buffer = buffer;
         this.offset = ref offset;
-        Endianness = endianness ?? Platform.Endianness;
+        this.numberSerializer = numberSerializer;
     }
 
-    readonly ref int offset;
-    readonly Span<byte> buffer;
+    /// <summary>
+    ///     Initialize a new <see cref="BinarySpanWriter" /> for <paramref name="buffer" />
+    /// </summary>
+    /// <param name="buffer">Byte buffer to be written</param>
+    /// <param name="offset">Write offset reference</param>
+    /// <param name="endianness">Serialization endianness</param>
+    public BinarySpanWriter(scoped in Span<byte> buffer, ref int offset, Endianness endianness)
+        : this(in buffer, ref offset, EndiannessSerializer.Get(endianness)) { }
+
+    /// <summary>
+    ///     Initialize a new <see cref="BinarySpanWriter" /> for <paramref name="buffer" />
+    /// </summary>
+    /// <param name="buffer">Byte buffer to be written</param>
+    /// <param name="offset">Write offset reference</param>
+    public BinarySpanWriter(scoped in Span<byte> buffer, ref int offset)
+        : this(in buffer, ref offset, Platform.Endianness) { }
 
-    /// <summary>Gets or init the value to define which endianness should be used for serialization.</summary>
-    public readonly Endianness Endianness;
+    /// <summary>Gets current serialization endianness.</summary>
+    public Endianness Endianness => numberSerializer.Endianness;
 
     /// <summary>Total written byte count.</summary>
     public int WrittenCount => offset;

src/Backdash/Serialization/Internal/BinarySerializerFactory.cs

@@ -1,4 +1,5 @@
 using System.Numerics;
+using Backdash.Core;
 using Backdash.Network;
 
 namespace Backdash.Serialization.Internal;
@@ -7,7 +8,7 @@ static class BinarySerializerFactory
 {
     public static IBinarySerializer<TInput> ForInteger<TInput>(Endianness? endianness = null)
         where TInput : unmanaged, IBinaryInteger<TInput>, IMinMaxValue<TInput> =>
-        IntegerBinarySerializer.Create<TInput>(endianness);
+        IntegerBinarySerializer.Create<TInput>(Mem.IsUnsigned<TInput>(), endianness);
 
     public static IBinarySerializer<TInput> ForInteger<TInput>(bool isUnsigned, Endianness? endianness = null)
         where TInput : unmanaged, IBinaryInteger<TInput> =>