[Proto] Metadata and Deserialization design

Linwenxuan04 · Linwenxuan04 · commit c3bb76dd457e · 2025-04-15T03:10:01.000+08:00
diff --git a/Lagrange.Proto/Serialization/Converter/Generic/ProtoNullableConverter.cs b/Lagrange.Proto/Serialization/Converter/Generic/ProtoNullableConverter.cs
@@ -0,0 +1,21 @@
+using Lagrange.Proto.Primitives;
+using Lagrange.Proto.Serialization.Metadata;
+
+namespace Lagrange.Proto.Serialization.Converter.Generic;
+
+internal class ProtoNullableConverter<T> : ProtoConverter<T?> where T : struct
+{
+    private readonly ProtoConverter<T> _converter = ProtoTypeResolver.GetConverter<T>();
+
+    public override WireType WireType => _converter.WireType;
+    
+    public override void Write(int field, ProtoWriter writer, T? value)
+    {
+        if (value.HasValue) _converter.Write(0, writer, value.Value);
+    }
+
+    public override T? Read(int field, ref ProtoReader reader)
+    {
+        return _converter.Read(field, ref reader);
+    }
+}
diff --git a/Lagrange.Proto/Serialization/Converter/Value/ProtoBooleanConverter.cs b/Lagrange.Proto/Serialization/Converter/Value/ProtoBooleanConverter.cs
@@ -0,0 +1,20 @@
+using System.Runtime.CompilerServices;
+using Lagrange.Proto.Primitives;
+
+namespace Lagrange.Proto.Serialization.Converter;
+
+internal class ProtoBooleanConverter : ProtoConverter<bool>
+{
+    public override WireType WireType => WireType.VarInt;
+    
+    public override void Write(int field, ProtoWriter writer, bool value)
+    {
+        writer.WriteRawByte(Unsafe.As<bool, byte>(ref value));
+    }
+
+    public override bool Read(int field, ref ProtoReader reader)
+    {
+        byte b = reader.DecodeVarInt<byte>();
+        return Unsafe.As<byte, bool>(ref b);
+    }
+}
diff --git a/Lagrange.Proto/Serialization/Converter/Value/ProtoBytesConverter.cs b/Lagrange.Proto/Serialization/Converter/Value/ProtoBytesConverter.cs
@@ -0,0 +1,26 @@
+using Lagrange.Proto.Primitives;
+
+namespace Lagrange.Proto.Serialization.Converter;
+
+public class ProtoBytesConverter : ProtoConverter<byte[]>
+{
+    public override WireType WireType => WireType.LengthDelimited;
+    
+    public override void Write(int field, ProtoWriter writer, byte[] value)
+    {
+        writer.EncodeVarInt(value.Length);
+        writer.WriteRawBytes(value);
+    }
+
+    public override byte[] Read(int field, ref ProtoReader reader)
+    {
+        int length = reader.DecodeVarInt<int>();
+        if (length == 0) return [];
+
+        var buffer = GC.AllocateUninitializedArray<byte>(length);
+        var span = reader.CreateSpan(length);
+        span.CopyTo(buffer);
+        
+        return buffer;
+    }
+}
diff --git a/Lagrange.Proto/Serialization/Converter/Value/ProtoFixed32Converter.cs b/Lagrange.Proto/Serialization/Converter/Value/ProtoFixed32Converter.cs
@@ -0,0 +1,19 @@
+using System.Numerics;
+using Lagrange.Proto.Primitives;
+
+namespace Lagrange.Proto.Serialization.Converter;
+
+internal class ProtoFixed32Converter<T> : ProtoConverter<T> where T : unmanaged, INumber<T>
+{
+    public override WireType WireType => WireType.Fixed32;
+    
+    public override void Write(int field, ProtoWriter writer, T value)
+    {
+        writer.EncodeFixed32<T>(value);
+    }
+
+    public override T Read(int field, ref ProtoReader reader)
+    {
+        return reader.DecodeFixed32<T>();
+    }
+}
diff --git a/Lagrange.Proto/Serialization/Converter/Value/ProtoFixed64Converter.cs b/Lagrange.Proto/Serialization/Converter/Value/ProtoFixed64Converter.cs
@@ -0,0 +1,19 @@
+using System.Numerics;
+using Lagrange.Proto.Primitives;
+
+namespace Lagrange.Proto.Serialization.Converter;
+
+internal class ProtoFixed64Converter<T> : ProtoConverter<T> where T : unmanaged, INumber<T>
+{
+    public override WireType WireType => WireType.Fixed64;
+    
+    public override void Write(int field, ProtoWriter writer, T value)
+    {
+        writer.EncodeFixed64<T>(value);
+    }
+
+    public override T Read(int field, ref ProtoReader reader)
+    {
+        return reader.DecodeFixed64<T>();
+    }
+}
diff --git a/Lagrange.Proto/Serialization/Converter/Value/ProtoReadOnlyMemoryByteConverter.cs b/Lagrange.Proto/Serialization/Converter/Value/ProtoReadOnlyMemoryByteConverter.cs
@@ -0,0 +1,25 @@
+using Lagrange.Proto.Primitives;
+
+namespace Lagrange.Proto.Serialization.Converter;
+
+public class ProtoReadOnlyMemoryByteConverter : ProtoConverter<ReadOnlyMemory<byte>>
+{
+    public override WireType WireType => WireType.LengthDelimited;
+    
+    public override void Write(int field, ProtoWriter writer, ReadOnlyMemory<byte> value)
+    {
+        writer.EncodeVarInt(value.Length);
+        writer.WriteRawBytes(value.Span);
+    }
+
+    public override ReadOnlyMemory<byte> Read(int field, ref ProtoReader reader)
+    {
+        int length = reader.DecodeVarInt<int>();
+        if (length == 0) return ReadOnlyMemory<byte>.Empty;
+        
+        var buffer = GC.AllocateUninitializedArray<byte>(length);
+        var span = reader.CreateSpan(length);
+        span.CopyTo(buffer);
+        return new ReadOnlyMemory<byte>(buffer, 0, length);
+    }
+}
diff --git a/Lagrange.Proto/Serialization/Converter/Value/ProtoStringConverter.cs b/Lagrange.Proto/Serialization/Converter/Value/ProtoStringConverter.cs
@@ -0,0 +1,23 @@
+using System.Text;
+using Lagrange.Proto.Primitives;
+
+namespace Lagrange.Proto.Serialization.Converter;
+
+internal class ProtoStringConverter : ProtoConverter<string>
+{
+    public override WireType WireType => WireType.LengthDelimited;
+    
+    public override void Write(int field, ProtoWriter writer, string value)
+    { 
+        writer.EncodeString(value);
+    }
+
+    public override string Read(int field, ref ProtoReader reader)
+    {
+        int length = reader.DecodeVarInt<int>();
+        var span = reader.CreateSpan(length);
+        if (span.IsEmpty) return string.Empty;
+        
+        return Encoding.UTF8.GetString(span);
+    }
+}
diff --git a/Lagrange.Proto/Serialization/Converter/Value/ProtoVarIntConverter.cs b/Lagrange.Proto/Serialization/Converter/Value/ProtoVarIntConverter.cs
@@ -0,0 +1,19 @@
+using System.Numerics;
+using Lagrange.Proto.Primitives;
+
+namespace Lagrange.Proto.Serialization.Converter;
+
+internal class ProtoVarIntConverter<T> : ProtoConverter<T> where T : unmanaged, INumber<T>
+{
+    public override WireType WireType => WireType.VarInt;
+    
+    public override void Write(int field, ProtoWriter writer, T value)
+    {
+        writer.EncodeVarInt<T>(value);
+    }
+
+    public override T Read(int field, ref ProtoReader reader)
+    {
+        return reader.DecodeVarInt<T>();
+    }
+}
diff --git a/Lagrange.Proto/Serialization/Metadata/ProtoFieldInfo.cs b/Lagrange.Proto/Serialization/Metadata/ProtoFieldInfo.cs
@@ -1,7 +1,9 @@
 ﻿using System.Diagnostics;
+using Lagrange.Proto.Primitives;
 
 namespace Lagrange.Proto.Serialization.Metadata;
 
+[DebuggerDisplay("{DebuggerDisplay,nq}")]
 public abstract class ProtoFieldInfo(int field, WireType wireType, Type declared, Type property)
 {
     public int Field { get; } = field;
@@ -30,10 +32,23 @@ internal ProtoConverter EffectiveConverter
     private protected ProtoConverter? _effectiveConverter;
     private protected abstract void SetGetter(Delegate? getter);
     private protected abstract void SetSetter(Delegate? setter);
+
+    public abstract void Read(ref ProtoReader reader, object target);
+        
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    private string DebuggerDisplay => $"Field = {Field}, WireType = {WireType}, PropertyType = {PropertyType}, DeclaredType = {DeclaredType}";
+    
 }
 
-public class ProtoFieldInfo<T>(int field, WireType wireType, Type declared) : ProtoFieldInfo(field, wireType, declared, typeof(T))
+public class ProtoFieldInfo<T> : ProtoFieldInfo
 {
+    public ProtoFieldInfo(int field, WireType wireType, Type declared) : base(field, wireType, declared, typeof(T))
+    {
+        var converter = ProtoTypeResolver.GetConverter<T>();
+        _effectiveConverter = converter;
+        _typedEffectiveConverter = converter;
+    }
+    
     private Func<object, T>? _typedGet;
     private Action<object, T>? _typedSet;
 
@@ -59,7 +74,7 @@ public class ProtoFieldInfo<T>(int field, WireType wireType, Type declared) : Pr
     }
 
     private ProtoConverter<T>? _typedEffectiveConverter;
-    
+
     private protected override void SetGetter(Delegate? getter)
     {
         Debug.Assert(getter is null or Func<object, object?> or Func<object, T>);
@@ -103,4 +118,12 @@ private protected override void SetSetter(Delegate? setter)
                 break;
         }
     }
+    
+    public override void Read(ref ProtoReader reader, object target)
+    {
+        Debug.Assert(_typedEffectiveConverter != null);
+        
+        T value = _typedEffectiveConverter.Read(Field, ref reader);
+        _typedSet?.Invoke(target, value);
+    }
 }
diff --git a/Lagrange.Proto/Serialization/Metadata/ProtoTypeInfo.cs b/Lagrange.Proto/Serialization/Metadata/ProtoTypeInfo.cs
diff --git a/Lagrange.Proto/Serialization/Metadata/ProtoTypeInfoResolver.cs b/Lagrange.Proto/Serialization/Metadata/ProtoTypeInfoResolver.cs
diff --git a/Lagrange.Proto/Serialization/Metadata/ProtoTypeResolver.WellKnownTypes.cs b/Lagrange.Proto/Serialization/Metadata/ProtoTypeResolver.WellKnownTypes.cs
@@ -0,0 +1,31 @@
+﻿using Lagrange.Proto.Serialization.Converter;
+
+namespace Lagrange.Proto.Serialization.Metadata;
+
+public static partial class ProtoTypeResolver
+{
+    private static void RegisterWellKnownTypes()
+    {
+        Register(new ProtoVarIntConverter<SByte>());
+        Register(new ProtoVarIntConverter<Byte>());
+        Register(new ProtoVarIntConverter<Int16>());
+        Register(new ProtoVarIntConverter<UInt16>());
+        Register(new ProtoVarIntConverter<Int32>());
+        Register(new ProtoVarIntConverter<UInt32>());
+        Register(new ProtoVarIntConverter<Int64>());
+        Register(new ProtoVarIntConverter<UInt64>());
+
+        Register(new ProtoFixed32Converter<Single>());
+        Register(new ProtoFixed32Converter<UInt32>());
+        Register(new ProtoFixed32Converter<Int32>());
+
+        Register(new ProtoFixed64Converter<Double>());
+        Register(new ProtoFixed64Converter<UInt64>());
+        Register(new ProtoFixed64Converter<Int64>());
+
+        Register(new ProtoBooleanConverter());
+        Register(new ProtoStringConverter());
+        Register(new ProtoBytesConverter());
+        Register(new ProtoReadOnlyMemoryByteConverter());
+    }
+}
diff --git a/Lagrange.Proto/Serialization/Metadata/ProtoTypeResolver.WellKnownTypes.tt b/Lagrange.Proto/Serialization/Metadata/ProtoTypeResolver.WellKnownTypes.tt
@@ -0,0 +1,53 @@
+<#@ template language="C#" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#
+Type[] varintTypes = [
+    typeof(sbyte),
+    typeof(byte),
+    typeof(short),
+    typeof(ushort),
+    typeof(int),
+    typeof(uint),
+    typeof(long),
+    typeof(ulong)
+    ];
+
+Type[] fixed32Types = [
+    typeof(float),
+    typeof(uint),
+    typeof(int)
+    ];
+
+Type[] fixed64Types = [
+    typeof(double),
+    typeof(ulong),
+    typeof(long)
+    ];
+#>
+using Lagrange.Proto.Serialization.Converter;
+
+namespace Lagrange.Proto.Serialization.Metadata;
+
+public static partial class ProtoTypeResolver
+{
+    private static void RegisterWellKnownTypes()
+    {
+<# foreach(var item in varintTypes) { #>
+        Register(new ProtoVarIntConverter<<#= item.Name #>>());
+<# } #>
+
+<# foreach(var item in fixed32Types) { #>
+        Register(new ProtoFixed32Converter<<#= item.Name #>>());
+<# } #>
+
+<# foreach(var item in fixed64Types) { #>
+        Register(new ProtoFixed64Converter<<#= item.Name #>>());
+<# } #>
+
+        Register(new ProtoBooleanConverter());
+        Register(new ProtoStringConverter());
+        Register(new ProtoBytesConverter());
+        Register(new ProtoReadOnlyMemoryByteConverter());
+    }
+}
diff --git a/Lagrange.Proto/Serialization/Metadata/ProtoTypeResolver.cs b/Lagrange.Proto/Serialization/Metadata/ProtoTypeResolver.cs
diff --git a/Lagrange.Proto/Serialization/ProtoConverter.cs b/Lagrange.Proto/Serialization/ProtoConverter.cs
diff --git a/Lagrange.Proto/Serialization/ProtoSerializer.Serialize.cs b/Lagrange.Proto/Serialization/ProtoSerializer.Serialize.cs
