Add MemoryPackReader. PeekIsNull,

TryPeekObjectHeader, TryPeekUnionHeader, TryPeekCollectionHeader

Author: neuecc

README.md

@@ -940,19 +940,31 @@ public readonly partial struct SerializableAnimationCurve
 
 The type to wrap is public, but excluded from serialization (`MemoryPackIgnore`). The properties you want to serialize are private, but included (`MemoryPackInclude`). Two patterns of constructors should also be prepared. The constructor used by the serializer should be private.
 
-As it is, it must be wrapped every time, which is inconvenient. Let's create a custom formatter.
+As it is, it must be wrapped every time, which is inconvenient. And also strcut wrapper can not represents null. So let's create a custom formatter.
 
 ```csharp
 public class AnimationCurveFormatter : MemoryPackFormatter<AnimationCurve>
 {
     // Unity does not support scoped and TBufferWriter so change signature to `Serialize(ref MemoryPackWriter writer, ref AnimationCurve value)`
-    public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref AnimationCurve value)
+    public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref AnimationCurve? value)
     {
+        if (value == null)
+        {
+            writer.WriteNullObjectHeader();
+            return;
+        }
+
         writer.WritePackable(new SerializableAnimationCurve(value));
     }
 
-    public override void Deserialize(ref MemoryPackReader reader, scoped ref AnimationCurve value)
+    public override void Deserialize(ref MemoryPackReader reader, scoped ref AnimationCurve? value)
     {
+        if (reader.PeekIsNull())
+        {
+            value = null;
+            return;
+        }
+        
         var wrapped = reader.ReadPackable<SerializableAnimationCurve>();
         value = wrapped.AnimationCurve;
     }

src/MemoryPack.Core/MemoryPackReader.cs

@@ -294,6 +294,55 @@ public bool TryReadCollectionHeader(out int length)
         return length != MemoryPackCode.NullCollection;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool PeekIsNull()
+    {
+        return TryPeekObjectHeader(out _);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPeekObjectHeader(out byte memberCount)
+    {
+        memberCount = GetSpanReference(1);
+        return memberCount != MemoryPackCode.NullObject;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPeekUnionHeader(out ushort tag)
+    {
+        var firstTag = GetSpanReference(1);
+        if (firstTag < MemoryPackCode.WideTag)
+        {
+            tag = firstTag;
+            return true;
+        }
+        else if (firstTag == MemoryPackCode.WideTag)
+        {
+            ref var spanRef = ref GetSpanReference(sizeof(ushort) + 1); // skip firstTag
+            tag = Unsafe.ReadUnaligned<ushort>(ref Unsafe.Add(ref spanRef, 1));
+            return true;
+        }
+        else
+        {
+            tag = 0;
+            return false;
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPeekCollectionHeader(out int length)
+    {
+        length = Unsafe.ReadUnaligned<int>(ref GetSpanReference(4));
+
+        // If collection-length is larger than buffer-length, it is invalid data.
+        if (Remaining < length)
+        {
+            MemoryPackSerializationException.ThrowInsufficientBufferUnless(length);
+        }
+
+        return length != MemoryPackCode.NullCollection;
+    }
+
     /// <summary>
     /// no validate collection size, be careful to use.
     /// </summary>

src/MemoryPack.Unity/Assets/Plugins/MemoryPack/Runtime/MemoryPack.Core/MemoryPackReader.cs

@@ -303,6 +303,55 @@ public bool TryReadCollectionHeader(out int length)
         return length != MemoryPackCode.NullCollection;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool PeekIsNull()
+    {
+        return TryPeekObjectHeader(out _);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPeekObjectHeader(out byte memberCount)
+    {
+        memberCount = GetSpanReference(1);
+        return memberCount != MemoryPackCode.NullObject;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPeekUnionHeader(out ushort tag)
+    {
+        var firstTag = GetSpanReference(1);
+        if (firstTag < MemoryPackCode.WideTag)
+        {
+            tag = firstTag;
+            return true;
+        }
+        else if (firstTag == MemoryPackCode.WideTag)
+        {
+            ref var spanRef = ref GetSpanReference(sizeof(ushort) + 1); // skip firstTag
+            tag = Unsafe.ReadUnaligned<ushort>(ref Unsafe.Add(ref spanRef, 1));
+            return true;
+        }
+        else
+        {
+            tag = 0;
+            return false;
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPeekCollectionHeader(out int length)
+    {
+        length = Unsafe.ReadUnaligned<int>(ref GetSpanReference(4));
+
+        // If collection-length is larger than buffer-length, it is invalid data.
+        if (Remaining < length)
+        {
+            MemoryPackSerializationException.ThrowInsufficientBufferUnless(length);
+        }
+
+        return length != MemoryPackCode.NullCollection;
+    }
+
     /// <summary>
     /// no validate collection size, be careful to use.
     /// </summary>

src/MemoryPack.Unity/Assets/Scripts/SampleOne.cs

@@ -1,4 +1,6 @@
-using MemoryPack;
+#nullable disable
+
+using MemoryPack;
 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
@@ -20,3 +22,60 @@ public partial class MyPerson
     public int Age { get; set; }
     public string Name { get; set; }
 }
+
+#nullable enable
+
+[MemoryPackable]
+public readonly partial struct SerializableAnimationCurve
+{
+    [MemoryPackIgnore]
+    public readonly AnimationCurve AnimationCurve;
+
+    [MemoryPackInclude]
+    WrapMode preWrapMode => AnimationCurve.preWrapMode;
+    [MemoryPackInclude]
+    WrapMode postWrapMode => AnimationCurve.postWrapMode;
+    [MemoryPackInclude]
+    Keyframe[] keys => AnimationCurve.keys;
+
+    [MemoryPackConstructor]
+    SerializableAnimationCurve(WrapMode preWrapMode, WrapMode postWrapMode, Keyframe[] keys)
+    {
+        var curve = new AnimationCurve(keys);
+        curve.preWrapMode = preWrapMode;
+        curve.postWrapMode = postWrapMode;
+        this.AnimationCurve = curve;
+    }
+
+    public SerializableAnimationCurve(AnimationCurve animationCurve)
+    {
+        this.AnimationCurve = animationCurve;
+    }
+}
+
+public class AnimationCurveFormatter : MemoryPackFormatter<AnimationCurve>
+{
+    // Unity does not support scoped and TBufferWriter so change signature to `Serialize(ref MemoryPackWriter writer, ref AnimationCurve value)`
+    public override void Serialize(ref MemoryPackWriter writer, scoped ref AnimationCurve? value)
+    {
+        if (value == null)
+        {
+            writer.WriteNullObjectHeader();
+            return;
+        }
+
+        writer.WritePackable(new SerializableAnimationCurve(value));
+    }
+
+    public override void Deserialize(ref MemoryPackReader reader, scoped ref AnimationCurve? value)
+    {
+        if (reader.PeekIsNull())
+        {
+            value = null;
+            return;
+        }
+
+        var wrapped = reader.ReadPackable<SerializableAnimationCurve>();
+        value = wrapped.AnimationCurve;
+    }
+}