Encode/decode short strings

Havret · Apr 16, 2024 · b34ae25 · b34ae25
1 parent bcabad6
commit b34ae25
Show file tree

Hide file tree

Showing 3 changed files with 71 additions and 4 deletions.
diff --git a/src/ArtemisNetCoreClient/ArtemisBinaryConverter.cs b/src/ArtemisNetCoreClient/ArtemisBinaryConverter.cs
@@ -7,9 +7,10 @@ namespace ActiveMQ.Artemis.Core.Client;
 internal static class ArtemisBinaryConverter
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static int ReadInt32(in ReadOnlySpan<byte> source)
+    public static int ReadInt32(in ReadOnlySpan<byte> source, out int value)
     {
-        return BinaryPrimitives.ReadInt32BigEndian(source);
+        value = BinaryPrimitives.ReadInt32BigEndian(source);
+        return sizeof(int);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -46,6 +47,14 @@ public static int WriteInt64(ref byte destination, long value)
         return sizeof(long);
     }
 
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int ReadInt16(in ReadOnlySpan<byte> source, out short value)
+    {
+        value = BinaryPrimitives.ReadInt16BigEndian(source);
+        return sizeof(short);
+    }
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static int WriteInt16(ref byte destination, short value)
     {
@@ -111,6 +120,33 @@ public static int GetStringByteCount(string value)
         return byteCount;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int ReadString(in ReadOnlySpan<byte> source, out string value)
+    {
+        var readBytes = ReadInt32(source, out var length);
+        if (length < 9)
+        {
+            Span<char> chars = stackalloc char[length];
+            for (int i = 0; i < length; i++)
+            {
+                readBytes += ReadInt16(source[readBytes..], out var c);
+                chars[i] = (char) c;
+            }
+
+            value = new string(chars);
+        }
+        else if (length < 0xFFF)
+        {
+            value = string.Empty;
+        }
+        else
+        {
+            value = string.Empty;
+        }
+
+        return readBytes;
+    }
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static int WriteString(ref byte destination, string value)
     {
@@ -135,7 +171,7 @@ private static int WriteAsShorts(ref byte destination, string value)
         var offset = 0;
         foreach (var c in value)
         {
-            offset += WriteInt16(ref destination, (short) c);
+            offset += WriteInt16(ref destination.GetOffset(offset), (short) c);
         }
 
         return offset;

diff --git a/src/ArtemisNetCoreClient/Transport2.cs b/src/ArtemisNetCoreClient/Transport2.cs
@@ -78,7 +78,7 @@ internal InboundPacket ReceivePacket()
     {
         Span<byte> frameSizeBuffer = stackalloc byte[sizeof(int)];
         _ = _reader.Read(frameSizeBuffer);
-        var frameSize = ArtemisBinaryConverter.ReadInt32(frameSizeBuffer);
+        _ = ArtemisBinaryConverter.ReadInt32(frameSizeBuffer, out var frameSize);
 
         Span<byte> typeBuffer = stackalloc byte[sizeof(byte)];
         _ = _reader.Read(typeBuffer);

diff --git a/test/ArtemisNetCoreClient.Tests/ArtemisBinaryConverterSpec.cs b/test/ArtemisNetCoreClient.Tests/ArtemisBinaryConverterSpec.cs
@@ -90,5 +90,36 @@ public void should_decode_nullable_bool(byte[] encoded, bool? expected)
         // Assert
         Assert.Equal(expected, value);
         Assert.Equal(encoded.Length, readBytes);
+    }
+
+    [Fact]
+    public void should_encode_short_string()
+    {
+        // Arrange
+        var str = "abcdefgh";
+        var byteCount = ArtemisBinaryConverter.GetStringByteCount(str);
+        var byteBuffer = new byte[byteCount];
+
+        // Act
+        var writtenBytes = ArtemisBinaryConverter.WriteString(ref byteBuffer.AsSpan().GetReference(), str);
+
+        // Assert
+        var expected = new byte[] { 0, 0, 0, 8, 0, 97, 0, 98, 0, 99, 0, 100, 0, 101, 0, 102, 0, 103, 0, 104 };
+        Assert.Equal(expected, byteBuffer);
+        Assert.Equal(byteCount, writtenBytes);
+    }
+
+    [Fact]
+    public void should_decode_short_string()
+    {
+        // Arrange
+        var byteBuffer = new byte[] { 0, 0, 0, 8, 0, 97, 0, 98, 0, 99, 0, 100, 0, 101, 0, 102, 0, 103, 0, 104 };
+
+        // Act
+        var readBytes = ArtemisBinaryConverter.ReadString(byteBuffer, out var value);
+
+        // Assert
+        Assert.Equal("abcdefgh", value);
+        Assert.Equal(byteBuffer.Length, readBytes);
     }    
 }