feat(C#): add C# implementation (WIP)

.gitignore

@@ -38,3 +38,5 @@ MODULE.bazel
 MODULE.bazel.lock
 .DS_Store
 **/.DS_Store
+csharp/**/bin
+csharp/**/obj

csharp/.csharpierrc.yaml

@@ -0,0 +1 @@
+printWidth: 120

csharp/Fury.Testing/Fakes/SinglePrimitiveFieldObject.cs

@@ -0,0 +1,36 @@
+using Fury.Serializer;
+
+namespace Fury.Testing.Fakes;
+
+public sealed class SinglePrimitiveFieldObject
+{
+    public int Value { get; set; }
+
+    public sealed class Serializer : AbstractSerializer<SinglePrimitiveFieldObject>
+    {
+        public override void Write(SerializationContext context, in SinglePrimitiveFieldObject value)
+        {
+            context.Writer.Write(value.Value);
+        }
+    }
+
+    public sealed class Deserializer : AbstractDeserializer<SinglePrimitiveFieldObject>
+    {
+        public override ValueTask<Box<SinglePrimitiveFieldObject>> CreateInstanceAsync(
+            DeserializationContext context,
+            CancellationToken cancellationToken = default
+        )
+        {
+            return new ValueTask<Box<SinglePrimitiveFieldObject>>(new SinglePrimitiveFieldObject());
+        }
+
+        public override async ValueTask ReadAndFillAsync(
+            DeserializationContext context,
+            Box<SinglePrimitiveFieldObject> instance,
+            CancellationToken cancellationToken = default
+        )
+        {
+            instance.Value!.Value = await context.Reader.ReadAsync<int>(cancellationToken);
+        }
+    }
+}

csharp/Fury.Testing/Fury.Testing.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+<!--        <TargetFrameworks>netstandard2.0;net8.0</TargetFrameworks>-->
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <LangVersion>12</LangVersion>
+        <IsPackable>false</IsPackable>
+        <IsTestProject>true</IsTestProject>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Bogus" Version="35.6.1" />
+        <PackageReference Include="coverlet.collector" Version="6.0.0"/>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0"/>
+        <PackageReference Include="xunit" Version="2.5.3"/>
+        <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <Using Include="Xunit"/>
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\Fury\Fury.csproj" />
+    </ItemGroup>
+
+</Project>

csharp/Fury.Testing/MetaStringTest.cs

@@ -0,0 +1,252 @@
+using System.Text;
+using Bogus;
+using Fury.Meta;
+
+namespace Fury.Testing;
+
+public sealed class MetaStringTest
+{
+    public static readonly IEnumerable<object[]> Lengths = Enumerable.Range(0, 9).Select(i => new object[] { i });
+
+    private static readonly string LowerSpecialChars = Enumerable
+        .Range(0, 1 << AbstractLowerSpecialEncoding.BitsPerChar)
+        .Select(i => (AbstractLowerSpecialEncoding.TryDecodeByte((byte)i, out var c), c))
+        .Where(t => t.Item1)
+        .Aggregate(new StringBuilder(), (builder, t) => builder.Append(t.c))
+        .ToString();
+
+    private static readonly string AllToLowerSpecialChars = Enumerable
+        .Range(0, 1 << AbstractLowerSpecialEncoding.BitsPerChar)
+        .Select(i => (AbstractLowerSpecialEncoding.TryDecodeByte((byte)i, out var c), c))
+        .Where(t => t.Item1 && t.c != AllToLowerSpecialEncoding.UpperCaseFlag)
+        .Aggregate(new StringBuilder(), (builder, t) => builder.Append(t.c).Append(char.ToUpperInvariant(t.c)))
+        .ToString();
+
+    private static readonly string TypeNameLowerUpperDigitSpecialChars = Enumerable
+        .Range(0, 1 << LowerUpperDigitSpecialEncoding.BitsPerChar)
+        .Select(i => (Encodings.TypeNameEncoding.LowerUpperDigit.TryDecodeByte((byte)i, out var c), c))
+        .Where(t => t.Item1 && char.IsLetterOrDigit(t.c))
+        .Aggregate(new StringBuilder(), (builder, t) => builder.Append(t.c))
+        .ToString();
+
+    private static readonly string NamespaceLowerUpperDigitSpecialChars = Enumerable
+        .Range(0, 1 << LowerUpperDigitSpecialEncoding.BitsPerChar)
+        .Select(i => (Encodings.NamespaceEncoding.LowerUpperDigit.TryDecodeByte((byte)i, out var c), c))
+        .Where(t => t.Item1 && char.IsLetterOrDigit(t.c))
+        .Aggregate(new StringBuilder(), (builder, t) => builder.Append(t.c))
+        .ToString();
+
+    [Theory]
+    [MemberData(nameof(Lengths))]
+    public void LowerSpecialEncoding_InputString_ShouldReturnTheSame(int length)
+    {
+        var faker = new Faker();
+        var stubString = faker.Random.String2(length, LowerSpecialChars);
+
+        var bufferLength = LowerSpecialEncoding.Instance.GetByteCount(stubString);
+        Span<byte> buffer = stackalloc byte[bufferLength];
+        LowerSpecialEncoding.Instance.GetBytes(stubString, buffer);
+        var output = LowerSpecialEncoding.Instance.GetString(buffer);
+
+        Assert.Equal(stubString, output);
+    }
+
+    [Theory]
+    [MemberData(nameof(Lengths))]
+    public void LowerSpecialEncoding_InputSeparatedBytes_ShouldReturnConcatenatedString(int length)
+    {
+        var faker = new Faker();
+        var stubString = faker.Random.String2(length, LowerSpecialChars);
+
+        var bufferLength = LowerSpecialEncoding.Instance.GetByteCount(stubString);
+        Span<byte> bytes = stackalloc byte[bufferLength];
+        Span<char> chars = stackalloc char[stubString.Length];
+        LowerSpecialEncoding.Instance.GetBytes(stubString, bytes);
+        var decoder = LowerSpecialEncoding.Instance.GetDecoder();
+        var emptyChars = chars;
+        for (var i = 0; i < bytes.Length; i++)
+        {
+            var slicedBytes = bytes.Slice(i, 1);
+            decoder.Convert(slicedBytes, emptyChars, i == bytes.Length - 1, out _, out var charsUsed, out _);
+            emptyChars = emptyChars.Slice(charsUsed);
+        }
+
+        var output = chars.ToString();
+
+        Assert.Equal(stubString, output);
+    }
+
+    [Theory]
+    [MemberData(nameof(Lengths))]
+    public void FirstToLowerSpecialEncoding_InputString_ShouldReturnTheSame(int length)
+    {
+        var faker = new Faker();
+        var stubString = faker.Random.String2(length, LowerSpecialChars);
+        if (stubString.Length > 0 && char.IsLower(stubString[0]))
+        {
+            Span<char> stubSpan = stackalloc char[stubString.Length];
+            stubString.AsSpan().CopyTo(stubSpan);
+            stubSpan[0] = char.ToUpperInvariant(stubSpan[0]);
+            stubString = stubSpan.ToString();
+        }
+
+        var bufferLength = FirstToLowerSpecialEncoding.Instance.GetByteCount(stubString);
+        Span<byte> buffer = stackalloc byte[bufferLength];
+        FirstToLowerSpecialEncoding.Instance.GetBytes(stubString, buffer);
+        var output = FirstToLowerSpecialEncoding.Instance.GetString(buffer);
+
+        Assert.Equal(stubString, output);
+    }
+
+    [Theory]
+    [MemberData(nameof(Lengths))]
+    public void FirstToLowerSpecialEncoding_InputSeparatedBytes_ShouldReturnConcatenatedString(int length)
+    {
+        var faker = new Faker();
+        var stubString = faker.Random.String2(length, LowerSpecialChars);
+        if (stubString.Length > 0 && char.IsLower(stubString[0]))
+        {
+            Span<char> stubSpan = stackalloc char[stubString.Length];
+            stubString.AsSpan().CopyTo(stubSpan);
+            stubSpan[0] = char.ToUpperInvariant(stubSpan[0]);
+            stubString = stubSpan.ToString();
+        }
+
+        var bufferLength = FirstToLowerSpecialEncoding.Instance.GetByteCount(stubString);
+        Span<byte> bytes = stackalloc byte[bufferLength];
+        Span<char> chars = stackalloc char[stubString.Length];
+        FirstToLowerSpecialEncoding.Instance.GetBytes(stubString, bytes);
+        var decoder = FirstToLowerSpecialEncoding.Instance.GetDecoder();
+        var emptyChars = chars;
+        for (var i = 0; i < bytes.Length; i++)
+        {
+            var slicedBytes = bytes.Slice(i, 1);
+            decoder.Convert(slicedBytes, emptyChars, i == bytes.Length - 1, out _, out var charsUsed, out _);
+            emptyChars = emptyChars.Slice(charsUsed);
+        }
+
+        var output = chars.ToString();
+
+        Assert.Equal(stubString, output);
+    }
+
+    [Theory]
+    [MemberData(nameof(Lengths))]
+    public void AllToLowerSpecialEncoding_InputString_ShouldReturnTheSame(int length)
+    {
+        var faker = new Faker();
+        var stubString = faker.Random.String2(length, AllToLowerSpecialChars);
+
+        var bufferLength = AllToLowerSpecialEncoding.Instance.GetByteCount(stubString);
+        Span<byte> buffer = stackalloc byte[bufferLength];
+        AllToLowerSpecialEncoding.Instance.GetBytes(stubString, buffer);
+        var output = AllToLowerSpecialEncoding.Instance.GetString(buffer);
+
+        Assert.Equal(stubString, output);
+    }
+
+    [Theory]
+    [MemberData(nameof(Lengths))]
+    public void AllToLowerSpecialEncoding_InputSeparatedBytes_ShouldReturnConcatenatedString(int length)
+    {
+        var faker = new Faker();
+        var stubString = faker.Random.String2(length, AllToLowerSpecialChars);
+
+        var bufferLength = AllToLowerSpecialEncoding.Instance.GetByteCount(stubString);
+        Span<byte> bytes = stackalloc byte[bufferLength];
+        Span<char> chars = stackalloc char[stubString.Length];
+        AllToLowerSpecialEncoding.Instance.GetBytes(stubString, bytes);
+        var decoder = AllToLowerSpecialEncoding.Instance.GetDecoder();
+        var emptyChars = chars;
+        for (var i = 0; i < bytes.Length; i++)
+        {
+            var slicedBytes = bytes.Slice(i, 1);
+            decoder.Convert(slicedBytes, emptyChars, i == bytes.Length - 1, out _, out var charsUsed, out _);
+            emptyChars = emptyChars.Slice(charsUsed);
+        }
+
+        var output = chars.ToString();
+
+        Assert.Equal(stubString, output);
+    }
+
+    [Theory]
+    [MemberData(nameof(Lengths))]
+    public void TypeNameLowerUpperDigitSpecialEncoding_InputString_ShouldReturnTheSame(int length)
+    {
+        var faker = new Faker();
+        var stubString = faker.Random.String2(length, TypeNameLowerUpperDigitSpecialChars);
+
+        var bufferLength = Encodings.TypeNameEncoding.LowerUpperDigit.GetByteCount(stubString);
+        Span<byte> buffer = stackalloc byte[bufferLength];
+        Encodings.TypeNameEncoding.LowerUpperDigit.GetBytes(stubString, buffer);
+        var output = Encodings.TypeNameEncoding.LowerUpperDigit.GetString(buffer);
+
+        Assert.Equal(stubString, output);
+    }
+
+    [Theory]
+    [MemberData(nameof(Lengths))]
+    public void TypeNameLowerUpperDigitSpecialEncoding_InputSeparatedBytes_ShouldReturnConcatenatedString(int length)
+    {
+        var faker = new Faker();
+        var stubString = faker.Random.String2(length, TypeNameLowerUpperDigitSpecialChars);
+
+        var bufferLength = Encodings.TypeNameEncoding.LowerUpperDigit.GetByteCount(stubString);
+        Span<byte> bytes = stackalloc byte[bufferLength];
+        Span<char> chars = stackalloc char[stubString.Length];
+        Encodings.TypeNameEncoding.LowerUpperDigit.GetBytes(stubString, bytes);
+        var decoder = Encodings.TypeNameEncoding.LowerUpperDigit.GetDecoder();
+        var emptyChars = chars;
+        for (var i = 0; i < bytes.Length; i++)
+        {
+            var slicedBytes = bytes.Slice(i, 1);
+            decoder.Convert(slicedBytes, emptyChars, i == bytes.Length - 1, out _, out var charsUsed, out _);
+            emptyChars = emptyChars.Slice(charsUsed);
+        }
+
+        var output = chars.ToString();
+
+        Assert.Equal(stubString, output);
+    }
+
+    [Theory]
+    [MemberData(nameof(Lengths))]
+    public void NamespaceLowerUpperDigitSpecialEncoding_InputString_ShouldReturnTheSame(int length)
+    {
+        var faker = new Faker();
+        var stubString = faker.Random.String2(length, NamespaceLowerUpperDigitSpecialChars);
+
+        var bufferLength = Encodings.NamespaceEncoding.LowerUpperDigit.GetByteCount(stubString);
+        Span<byte> buffer = stackalloc byte[bufferLength];
+        Encodings.NamespaceEncoding.LowerUpperDigit.GetBytes(stubString, buffer);
+        var output = Encodings.NamespaceEncoding.LowerUpperDigit.GetString(buffer);
+
+        Assert.Equal(stubString, output);
+    }
+
+    [Theory]
+    [MemberData(nameof(Lengths))]
+    public void NamespaceLowerUpperDigitSpecialEncoding_InputSeparatedBytes_ShouldReturnConcatenatedString(int length)
+    {
+        var faker = new Faker();
+        var stubString = faker.Random.String2(length, NamespaceLowerUpperDigitSpecialChars);
+
+        var bufferLength = Encodings.NamespaceEncoding.LowerUpperDigit.GetByteCount(stubString);
+        Span<byte> bytes = stackalloc byte[bufferLength];
+        Span<char> chars = stackalloc char[stubString.Length];
+        Encodings.NamespaceEncoding.LowerUpperDigit.GetBytes(stubString, bytes);
+        var decoder = Encodings.NamespaceEncoding.LowerUpperDigit.GetDecoder();
+        var emptyChars = chars;
+        for (var i = 0; i < bytes.Length; i++)
+        {
+            var slicedBytes = bytes.Slice(i, 1);
+            decoder.Convert(slicedBytes, emptyChars, i == bytes.Length - 1, out _, out var charsUsed, out _);
+            emptyChars = emptyChars.Slice(charsUsed);
+        }
+
+        var output = chars.ToString();
+
+        Assert.Equal(stubString, output);
+    }
+}

csharp/Fury.slnx

@@ -0,0 +1,8 @@
+<Solution>
+  <Configurations>
+    <BuildType Name="Debug" />
+    <BuildType Name="Release" />
+  </Configurations>
+  <Project Path="Fury.Testing\Fury.Testing.csproj" Type="Classic C#" />
+  <Project Path="Fury\Fury.csproj" Type="Classic C#" />
+</Solution>

csharp/Fury/Backports/BitOperations.cs

@@ -0,0 +1,21 @@
+#if !NET8_0_OR_GREATER
+using System.Runtime.CompilerServices;
+
+// ReSharper disable once CheckNamespace
+namespace System.Numerics;
+
+internal static class BitOperations
+{
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ulong RotateLeft(ulong value, int offset) => (value << offset) | (value >> (64 - offset));
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint RotateLeft(uint value, int offset) => (value << offset) | (value >> (32 - offset));
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ulong RotateRight(ulong value, int offset) => (value >> offset) | (value << (64 - offset));
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint RotateRight(uint value, int offset) => (value >> offset) | (value << (32 - offset));
+}
+#endif

csharp/Fury/Backports/NotReturnAttributes.cs

@@ -0,0 +1,7 @@
+#if !NET8_0_OR_GREATER
+// ReSharper disable once CheckNamespace
+namespace System.Diagnostics.CodeAnalysis;
+
+[AttributeUsage(AttributeTargets.Method, Inherited = false)]
+internal class DoesNotReturnAttribute : Attribute;
+#endif