add VersionedSerialization + source generator

2024-08-13 04:27:23 +02:00
parent 30c019c4ef
commit 22ecdc3612
25 changed files with 1585 additions and 0 deletions
--- a/VersionedSerialization/SpanReader.cs
+++ b/VersionedSerialization/SpanReader.cs
@@ -0,0 +1,146 @@
+using System.Buffers.Binary;
+using System.Collections.Immutable;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace VersionedSerialization;
+
+// ReSharper disable ReplaceSliceWithRangeIndexer | The range indexer gets compiled into .Slice(x, y) and not .Slice(x) which worsens performance
+public ref struct SpanReader(ReadOnlySpan<byte> data, int offset = 0, bool littleEndian = true, bool is32Bit = false) : IReader
+{
+    public int Offset = offset;
+    public readonly byte Peek => _data[Offset];
+    public readonly bool IsLittleEndian => _littleEndian;
+    public readonly bool Is32Bit => _is32Bit;
+    public readonly int Length => _data.Length;
+    public readonly int PointerSize => Is32Bit ? sizeof(uint) : sizeof(ulong);
+
+    private readonly ReadOnlySpan<byte> _data = data;
+    private readonly bool _littleEndian = littleEndian;
+    private readonly bool _is32Bit = is32Bit;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private T ReadInternal<T>() where T : unmanaged
+    {
+        var value = MemoryMarshal.Read<T>(_data.Slice(Offset));
+        Offset += Unsafe.SizeOf<T>();
+        return value;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static TTo Cast<TFrom, TTo>(in TFrom from) => Unsafe.As<TFrom, TTo>(ref Unsafe.AsRef(in from));
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ReadOnlySpan<byte> ReadBytes(int length)
+    {
+        var val = _data.Slice(Offset, length);
+        Offset += length;
+        return val;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public T Read<T>() where T : unmanaged
+    {
+        if (typeof(T) == typeof(byte))
+            return Cast<byte, T>(_data[Offset++]);
+
+        var value = ReadInternal<T>();
+        if (!_littleEndian)
+        {
+            if (value is ulong val)
+            {
+                var converted = BinaryPrimitives.ReverseEndianness(val);
+                value = Cast<ulong, T>(converted);
+            } 
+            else if (typeof(T) == typeof(long))
+            {
+                var converted = BinaryPrimitives.ReverseEndianness(Cast<T, long>(value));
+                value = Cast<long, T>(converted);
+            }
+            else if (typeof(T) == typeof(uint))
+            {
+                var converted = BinaryPrimitives.ReverseEndianness(Cast<T, uint>(value));
+                value = Cast<uint, T>(converted);
+            }
+            else if (typeof(T) == typeof(int))
+            {
+                var converted = BinaryPrimitives.ReverseEndianness(Cast<T, int>(value));
+                value = Cast<int, T>(converted);
+            }
+            else if (typeof(T) == typeof(ushort))
+            {
+                var converted = BinaryPrimitives.ReverseEndianness(Cast<T, ushort>(value));
+                value = Cast<ushort, T>(converted);
+            }
+            else if (typeof(T) == typeof(short))
+            {
+                var converted = BinaryPrimitives.ReverseEndianness(Cast<T, short>(value));
+                value = Cast<short, T>(converted);
+            }
+        }
+
+        return value;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ImmutableArray<T> ReadArray<T>(long count) where T : unmanaged
+    {
+        var array = ImmutableArray.CreateBuilder<T>(checked((int)count));
+        for (long i = 0; i < count; i++)
+            array.Add(Read<T>());
+
+        return array.MoveToImmutable();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public T ReadObject<T>(in StructVersion version = default) where T : IReadable, new()
+    {
+        var obj = new T();
+        obj.Read(ref this, in version);
+        return obj;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ImmutableArray<T> ReadObjectArray<T>(long count, in StructVersion version = default) where T : IReadable, new() 
+    {
+        var array = ImmutableArray.CreateBuilder<T>(checked((int)count));
+        for (long i = 0; i < count; i++)
+            array.Add(ReadObject<T>(in version));
+
+        return array.MoveToImmutable();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public string ReadString()
+    {
+        var length = _data.Slice(Offset).IndexOf(byte.MinValue);
+
+        if (length == -1)
+            throw new InvalidDataException("Failed to find string in span.");
+
+        var val = _data.Slice(Offset, length);
+        Offset += length + 1; // Skip null terminator
+
+        return Encoding.UTF8.GetString(val);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool ReadBoolean() => Read<byte>() != 0;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ulong ReadNUInt() => _is32Bit ? Read<uint>() : Read<ulong>();
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public long ReadNInt() => _is32Bit ? Read<int>() : Read<long>();
+
+    public void Align(int alignment = 0)
+    {
+        if (alignment == 0)
+            alignment = Is32Bit ? 4 : 8;
+
+        var rem = Offset % alignment;
+        if (rem != 0)
+            Offset += alignment - rem;
+    }
+}