Reader API finished

Author: neuecc

src/MemoryPack.Core/Formatters/BigIntegerFormatter.cs

@@ -1,4 +1,6 @@
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using System.Text;
 
 namespace MemoryPack.Formatters;
@@ -22,12 +24,15 @@ public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter
 
     public override void Deserialize(ref MemoryPackReader reader, scoped ref BigInteger value)
     {
-        if (reader.TryReadUnmanagedSpan<byte>(out var view, out var length))
+        if (!reader.TryReadCollectionHeader(out var length))
         {
-            value = new BigInteger(view);
-            reader.Advance(length);
+            value = default;
+            return;
         }
 
-        MemoryPackSerializationException.ThrowInvalidCollection();
+        ref var src = ref reader.GetSpanReference(length);
+        value = new BigInteger(MemoryMarshal.CreateReadOnlySpan(ref src, length));
+
+        reader.Advance(length);
     }
 }

src/MemoryPack.Core/MemoryPackReader.cs

@@ -172,18 +172,21 @@ public bool TryReadCollectionHeader(out int length)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public string? ReadString()
     {
-        if (!TryReadUnmanagedSpan<char>(out var view, out var advanceLength))
+        if (!TryReadCollectionHeader(out var length))
         {
             return null;
         }
-
-        if (view.Length == 0)
+        if (length == 0)
         {
             return "";
         }
 
-        var str = new string(view);
-        Advance(advanceLength);
+        var byteCount = length * 2;
+        ref var src = ref GetSpanReference(byteCount);
+
+        var str = new string(MemoryMarshal.CreateReadOnlySpan(ref Unsafe.As<byte, char>(ref src), length));
+
+        Advance(byteCount);
 
         return str;
     }
@@ -219,7 +222,7 @@ public void ReadObject<T>(scoped ref T? value)
         return value;
     }
 
-    #region ReadArray/Span(view)
+    #region ReadArray/Span
 
     public T?[]? ReadArray<T>()
     {
@@ -293,42 +296,10 @@ public void ReadSpan<T>(scoped ref Span<T?> value)
         }
     }
 
-    //public void ReadSpan<T>(scoped ref Span<T?> value)
-    //{
-    //    if (!RuntimeHelpers.IsReferenceOrContainsReferences<T>())
-    //    {
-    //        // DangerousReadUnmanaged(ref value);
-    //        // TODO:...?
-    //        throw new NotImplementedException();
-    //    }
-
-    //    if (!TryReadLengthHeader(out var length))
-    //    {
-    //        value = null;
-    //        return;
-    //    }
-
-    //    if (length == 0)
-    //    {
-    //        value = Array.Empty<T>();
-    //        return;
-    //    }
-
-    //    // T[] support overwrite
-    //    if (value == null || value.Length != length)
-    //    {
-    //        value = new T[length];
-    //    }
-
-    //    var formatter = MemoryPackFormatterProvider.GetFormatter<T>();
-    //    for (int i = 0; i < length; i++)
-    //    {
-    //        formatter.Deserialize(ref this, ref value[i]);
-    //    }
-    //}
-
     #endregion
 
+    #region UnmanagedArray/Span
+
     public T[]? ReadUnmanagedArray<T>()
         where T : unmanaged
     {
@@ -341,6 +312,12 @@ public void ReadUnmanagedArray<T>(scoped ref T[]? value)
         DangerousReadUnmanagedArray<T>(ref value);
     }
 
+    public void ReadUnmanagedSpan<T>(scoped ref Span<T> value)
+        where T : unmanaged
+    {
+        DangerousReadUnmanagedSpan<T>(ref value);
+    }
+
     // T: should be unamanged type
     public unsafe T[]? DangerousReadUnmanagedArray<T>()
     {
@@ -374,18 +351,18 @@ public unsafe void DangerousReadUnmanagedArray<T>(scoped ref T[]? value)
             return;
         }
 
-        var size = length * Unsafe.SizeOf<T>();
-        ref var src = ref GetSpanReference(size);
+        var byteCount = length * Unsafe.SizeOf<T>();
+        ref var src = ref GetSpanReference(byteCount);
 
         if (value == null || value.Length != length)
         {
             value = GC.AllocateUninitializedArray<T>(length);
         }
 
         ref var dest = ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(value));
-        Unsafe.CopyBlockUnaligned(ref dest, ref src, (uint)size);
+        Unsafe.CopyBlockUnaligned(ref dest, ref src, (uint)byteCount);
 
-        Advance(size);
+        Advance(byteCount);
     }
 
     public unsafe void DangerousReadUnmanagedSpan<T>(scoped ref Span<T> value)
@@ -402,48 +379,21 @@ public unsafe void DangerousReadUnmanagedSpan<T>(scoped ref Span<T> value)
             return;
         }
 
-        var size = length * Unsafe.SizeOf<T>();
-        ref var src = ref GetSpanReference(size);
+        var byteCount = length * Unsafe.SizeOf<T>();
+        ref var src = ref GetSpanReference(byteCount);
 
         if (value == null || value.Length != length)
         {
             value = GC.AllocateUninitializedArray<T>(length);
         }
 
         ref var dest = ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value));
-        Unsafe.CopyBlockUnaligned(ref dest, ref src, (uint)size);
-
-        Advance(size);
-    }
+        Unsafe.CopyBlockUnaligned(ref dest, ref src, (uint)byteCount);
 
-
-
-    // TODO:this?
-
-    public bool TryReadUnmanagedSpan<T>(out ReadOnlySpan<T> view, out int advanceLength)
-        where T : unmanaged
-    {
-        return DangerousTryReadUnmanagedSpan(out view, out advanceLength);
-    }
-
-    // T: should be unamanged type
-    public bool DangerousTryReadUnmanagedSpan<T>(out ReadOnlySpan<T> view, out int advanceLength)
-    {
-        if (!TryReadCollectionHeader(out var length))
-        {
-            view = default;
-            advanceLength = 0;
-            return false;
-        }
-
-        view = MemoryMarshal.CreateReadOnlySpan(ref Unsafe.As<byte, T>(ref GetSpanReference(length)), length);
-        advanceLength = view.Length * Unsafe.SizeOf<T>();
-        return true;
+        Advance(byteCount);
     }
 
-
-
-
+    #endregion
 
     public void ReadSpanWithoutReadLengthHeader<T>(int length, scoped ref Span<T?> value)
     {
@@ -460,12 +410,12 @@ public void ReadSpanWithoutReadLengthHeader<T>(int length, scoped ref Span<T?> v
                 value = GC.AllocateUninitializedArray<T>(length);
             }
 
-            var size = length * Unsafe.SizeOf<T>();
-            ref var src = ref GetSpanReference(size);
+            var byteCount = length * Unsafe.SizeOf<T>();
+            ref var src = ref GetSpanReference(byteCount);
             ref var dest = ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)!);
-            Unsafe.CopyBlockUnaligned(ref dest, ref src, (uint)size);
+            Unsafe.CopyBlockUnaligned(ref dest, ref src, (uint)byteCount);
 
-            Advance(size);
+            Advance(byteCount);
         }
         else
         {