Fixed compatibility with unsigned 7-bit encoding

Author: sakno

…otNext.IO/Buffers/Binary/Leb128Reader.cs …ffers/Binary/SevenBitEncodedIntReader.cssrc/DotNext.IO/Buffers/Binary/Leb128Reader.cs renamed to src/DotNext.IO/Buffers/Binary/SevenBitEncodedIntReader.cs src/DotNext.IO/Buffers/Binary/Leb128Reader.cs renamed to src/DotNext.IO/Buffers/Binary/SevenBitEncodedIntReader.cs

@@ -5,16 +5,15 @@
 namespace DotNext.Buffers.Binary;
 
 [StructLayout(LayoutKind.Auto)]
-internal struct Leb128Reader<T>() : IBufferReader, ISupplier<T>
-    where T : struct, IBinaryInteger<T>
+internal struct SevenBitEncodedIntReader() : IBufferReader, ISupplier<int>
 {
-    private Leb128<T> decoder;
+    private Leb128<uint> decoder;
     private bool incompleted = true;
 
     readonly int IBufferReader.RemainingBytes => Unsafe.BitCast<bool, byte>(incompleted);
 
     void IReadOnlySpanConsumer<byte>.Invoke(ReadOnlySpan<byte> source)
         => incompleted = decoder.Append(MemoryMarshal.GetReference(source));
 
-    readonly T ISupplier<T>.Invoke() => decoder.Value;
+    readonly int ISupplier<int>.Invoke() => (int)decoder.Value;
 }

src/DotNext.IO/Buffers/BufferWriter.cs

@@ -7,7 +7,7 @@ namespace DotNext.Buffers;
 
 using EncodingContext = DotNext.Text.EncodingContext;
 using LengthFormat = IO.LengthFormat;
-using SevenBitEncodedInt = Binary.Leb128<int>;
+using SevenBitEncodedInt = Binary.Leb128<uint>;
 
 /// <summary>
 /// Represents extension methods for writing typed data into buffer.
@@ -44,15 +44,17 @@ static void WriteSlow(IBufferWriter<T> writer, in ReadOnlySequence<T> value)
 
     internal static unsafe int WriteLength(this ref SpanWriter<byte> destination, int value, LengthFormat lengthFormat)
     {
-        delegate*<ref SpanWriter<byte>, int, int> writer = lengthFormat switch
+        Debug.Assert(value >= 0);
+        
+        delegate*<ref SpanWriter<byte>, uint, int> writer = lengthFormat switch
         {
             LengthFormat.LittleEndian => &ByteBuffer.WriteLittleEndian,
             LengthFormat.BigEndian => &ByteBuffer.WriteBigEndian,
-            LengthFormat.Compressed => &ByteBuffer.WriteLeb128<int>,
+            LengthFormat.Compressed => &ByteBuffer.WriteLeb128<uint>,
             _ => throw new ArgumentOutOfRangeException(nameof(lengthFormat)),
         };
 
-        return writer(ref destination, value);
+        return writer(ref destination, (uint)value);
     }
 
     internal static int WriteLength(this IBufferWriter<byte> buffer, int length, LengthFormat lengthFormat)

src/DotNext.IO/IO/FileReader.Binary.cs

@@ -127,7 +127,7 @@ ValueTask<TReader> IAsyncBinaryReader.ReadAsync<TReader>(TReader reader, Cancell
     {
         LengthFormat.LittleEndian => ReadLittleEndianAsync<int>(token),
         LengthFormat.BigEndian => ReadBigEndianAsync<int>(token),
-        LengthFormat.Compressed => ReadAsync<int, Leb128Reader<int>>(new(), token),
+        LengthFormat.Compressed => ReadAsync<int, SevenBitEncodedIntReader>(new(), token),
         _ => ValueTask.FromException<int>(new ArgumentOutOfRangeException(nameof(lengthFormat))),
     };
 

src/DotNext.IO/IO/FileWriter.Binary.cs

@@ -142,7 +142,7 @@ private int WriteLength(int length, LengthFormat lengthFormat)
     /// <exception cref="OperationCanceledException">The operation has been canceled.</exception>
     public async ValueTask WriteAsync(ReadOnlyMemory<byte> input, LengthFormat lengthFormat, CancellationToken token = default)
     {
-        if (FreeCapacity < Leb128<int>.MaxSizeInBytes)
+        if (FreeCapacity < Leb128<uint>.MaxSizeInBytes)
             await FlushAsync(token).ConfigureAwait(false);
 
         WriteLength(input.Length, lengthFormat);
@@ -164,7 +164,7 @@ public async ValueTask<long> EncodeAsync(ReadOnlyMemory<char> chars, EncodingCon
         long result;
         if (lengthFormat.HasValue)
         {
-            if (FreeCapacity < Leb128<int>.MaxSizeInBytes)
+            if (FreeCapacity < Leb128<uint>.MaxSizeInBytes)
                 await FlushAsync(token).ConfigureAwait(false);
 
             result = WriteLength(context.Encoding.GetByteCount(chars.Span), lengthFormat.GetValueOrDefault());
@@ -256,7 +256,7 @@ private bool TryFormat<T>(T value, LengthFormat? lengthFormat, ReadOnlySpan<char
         {
             null => 0,
             LengthFormat.BigEndian or LengthFormat.LittleEndian => sizeof(int),
-            LengthFormat.Compressed => Leb128<int>.MaxSizeInBytes,
+            LengthFormat.Compressed => Leb128<uint>.MaxSizeInBytes,
             _ => throw new ArgumentOutOfRangeException(nameof(lengthFormat)),
         };
 
@@ -289,7 +289,7 @@ private async ValueTask<int> FormatSlowAsync<T>(T value, LengthFormat? lengthFor
         if (!TryFormat(value, lengthFormat, format, provider, out var bytesWritten))
         {
             const int maxBufferSize = int.MaxValue / 2;
-            for (var bufferSize = MaxBufferSize + Leb128<int>.MaxSizeInBytes; ; bufferSize = bufferSize <= maxBufferSize ? bufferSize << 1 : throw new InsufficientMemoryException())
+            for (var bufferSize = MaxBufferSize + Leb128<uint>.MaxSizeInBytes; ; bufferSize = bufferSize <= maxBufferSize ? bufferSize << 1 : throw new InsufficientMemoryException())
             {
                 using var buffer = allocator.AllocateAtLeast(bufferSize);
                 if (value.TryFormat(buffer.Span, out bytesWritten, format, provider))

src/DotNext.IO/IO/IAsyncBinaryReader.cs

@@ -99,7 +99,7 @@ private async ValueTask<TResult> ReadAsync<TResult, TReader>(TReader reader, Can
     {
         LengthFormat.LittleEndian => ReadLittleEndianAsync<int>(token),
         LengthFormat.BigEndian => ReadBigEndianAsync<int>(token),
-        LengthFormat.Compressed => ReadAsync<int, Leb128Reader<int>>(new(), token),
+        LengthFormat.Compressed => ReadAsync<int, SevenBitEncodedIntReader>(new(), token),
         _ => ValueTask.FromException<int>(new ArgumentOutOfRangeException(nameof(lengthFormat))),
     };
 

src/DotNext.IO/IO/Pipelines/PipeExtensions.Readers.cs

@@ -154,7 +154,7 @@ public static ValueTask<T> ReadBigEndianAsync<T>(this PipeReader reader, Cancell
     {
         LengthFormat.LittleEndian => reader.ReadLittleEndianAsync<int>(token),
         LengthFormat.BigEndian => reader.ReadBigEndianAsync<int>(token),
-        LengthFormat.Compressed => ReadAsync<int, Leb128Reader<int>>(reader, new(), token),
+        LengthFormat.Compressed => ReadAsync<int, SevenBitEncodedIntReader>(reader, new(), token),
         _ => ValueTask.FromException<int>(new ArgumentOutOfRangeException(nameof(lengthFormat))),
     };
 

src/DotNext.IO/IO/SequenceReader.cs

@@ -271,8 +271,8 @@ public MemoryOwner<byte> ReadBlock(LengthFormat lengthFormat, MemoryAllocator<by
 
     private int Read7BitEncodedInt32()
     {
-        var parser = new Leb128Reader<int>();
-        return Read<int, Leb128Reader<int>>(ref parser);
+        var parser = new SevenBitEncodedIntReader();
+        return Read<int, SevenBitEncodedIntReader>(ref parser);
     }
 
     private int ReadLength(LengthFormat lengthFormat) => lengthFormat switch

src/DotNext.IO/IO/StreamExtensions.Readers.cs

@@ -118,7 +118,7 @@ private static unsafe ValueTask<int> ReadLengthAsync(this Stream stream, LengthF
         return reader(stream, buffer, token);
 
         static ValueTask<int> Read7BitEncodedIntAsync(Stream stream, Memory<byte> buffer, CancellationToken token)
-            => ReadAsync<int, Leb128Reader<int>>(stream, new(), buffer, token);
+            => ReadAsync<int, SevenBitEncodedIntReader>(stream, new(), buffer, token);
     }
 
     /// <summary>
@@ -136,7 +136,7 @@ public static async ValueTask<MemoryOwner<byte>> ReadBlockAsync(this Stream stre
     {
         MemoryOwner<byte> result;
         int length;
-        using (result = allocator.AllocateExactly(Leb128<int>.MaxSizeInBytes))
+        using (result = allocator.AllocateExactly(Leb128<uint>.MaxSizeInBytes))
         {
             length = await stream.ReadLengthAsync(lengthFormat, result.Memory, token).ConfigureAwait(false);
         }

src/DotNext.IO/IO/StreamExtensions.Writers.cs

@@ -191,7 +191,7 @@ public static async ValueTask<int> FormatAsync<T>(this Stream stream, T value, L
         Memory<byte> bufferForLength;
         if (lengthFormat.HasValue)
         {
-            bufferForLength = buffer.Slice(0, Leb128<int>.MaxSizeInBytes);
+            bufferForLength = buffer.Slice(0, Leb128<uint>.MaxSizeInBytes);
             buffer = buffer.Slice(bufferForLength.Length);
         }
         else