move unsafe value conversions to their own experimental public class

Author: domportera

sources/Input/Input/Implementations/EnumInfo.cs

@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Reflection;
-using System.Runtime.CompilerServices;
 
 namespace Silk.NET.Input;
 
@@ -143,6 +142,7 @@ static unsafe EnumInfo()
         MaxValue = AllValuesOrdered[^1];
     }
 
+#pragma warning disable ST0006 ST0007 ST0008 ST0009
     /// <summary>
     /// Gets the ordered index of the unnamed enum value provided. This index is calculated by:
     /// (the number of named members in this enum type) + (the raw value of the number if unnamed)
@@ -154,7 +154,7 @@ static unsafe EnumInfo()
     public static int ValueIndexOf(T value)
     {
         // happy path - it's a named value we've already computed
-        if(_numericallyDistinctIndices.TryGetValue(value, out var index))
+        if (_numericallyDistinctIndices.TryGetValue(value, out var index))
         {
             return index;
         }
@@ -166,46 +166,17 @@ public static int ValueIndexOf(T value)
             return -1;
         }
 
-        var rawValue = Convert<T, int>(value);
+        var rawValue = value.Convert<T, int>();
 
         // todo - don't rely on joystickButton's unknown - find the MinValue
-        if (rawValue <= 0 || rawValue >= Convert<ulong, int>(_allEnumValuesRaw[0]))
+        if (rawValue <= 0 || rawValue >= _allEnumValuesRaw[0].Convert<ulong, int>())
         {
             return -1;
         }
 
-        return  _allValuesOrdered.Length + rawValue;
+        return _allValuesOrdered.Length + rawValue;
     }
 
-    /// <summary>
-    /// Returns the numerical value of the enum value provided in a type-safe way
-    /// </summary>
-    /// <param name="value"></param>
-    /// <typeparam name="TFrom"></typeparam>
-    /// <typeparam name="TTo"></typeparam>
-    /// <returns></returns>
-    private static unsafe TTo Convert<TFrom, TTo>(TFrom value) where TTo : unmanaged where TFrom : unmanaged
-    {
-        if (sizeof(T) == sizeof(TTo))
-        {
-            return Unsafe.Read<TTo>(&value);
-        }
-
-        var minSize = Math.Min(sizeof(TTo), sizeof(T));
-
-        var originalValuePtr = (byte*)&value;
-
-        var valuePtr = &originalValuePtr[Math.Abs(minSize - sizeof(T))]; // does this assume little-endianness?
-        var numberPtr = stackalloc byte[sizeof(TTo)];
-
-        // ensure block is initialized (as it isnt guaranteed?) so any missing bytes of the output will stay 0
-        // if type TNumber is a larger size than type T
-        Unsafe.InitBlock(numberPtr, 0, (uint)sizeof(TTo));
-
-        var copyToPtr = &numberPtr[Math.Abs(minSize - sizeof(TTo))];
-        Buffer.MemoryCopy(valuePtr, copyToPtr, sizeof(TTo), minSize);
-        return *(TTo*)numberPtr;
-    }
 
     private static T[] OrderedValues<TNumber>(bool byNumericValue)
         where TNumber : unmanaged, IComparable<TNumber>
@@ -215,19 +186,21 @@ private static T[] OrderedValues<TNumber>(bool byNumericValue)
 
         if (byNumericValue)
         {
-            allValues = allValues.DistinctBy(Convert<T, TNumber>).ToArray();
+            allValues = allValues.DistinctBy(UnsafeNumericValueExtensions.Convert<T, TNumber>).ToArray();
         }
 
         // sort by increasing order
         allValues.AsSpan().StableSort((a, b) => {
-            var aNumber = Convert<T, TNumber>(a);
-            var bNumber = Convert<T, TNumber>(b);
+            var aNumber = a.Convert<T, TNumber>();
+            var bNumber = b.Convert<T, TNumber>();
             return aNumber.CompareTo(bNumber);
         });
 
         return allValues;
     }
 
+#pragma warning restore ST0006 ST0007 ST0008 ST0009
+
     private static bool IsIgnored(T value)
     {
         var attr = value.GetType().GetField(value.ToString())?.GetCustomAttribute<OrderedIndexIgnoreAttribute>();

sources/Input/Input/Implementations/UnsafeNumericValueExtensions.cs

@@ -0,0 +1,69 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace Silk.NET.Input;
+
+/// <summary>
+/// Some unsafe methods for comparing numeric values of simple numeric types.
+/// </summary>
+[Experimental(diagnosticId: "ST0006", UrlFormat = "https://dotnet.github.io/Silk.NET/docs/v3/silk.net/diagnostics/{0}")]
+public static class UnsafeNumericValueExtensions
+{
+    /// <param name="value"></param>
+    /// <typeparam name="T"></typeparam>
+    extension<T>(T value) where T : unmanaged
+    {
+        /// <summary>
+        /// Compares two values of the same type for equality.
+        /// Type must be no larger than 8 bytes.
+        /// </summary>
+        /// <param name="other"></param>
+        /// <returns></returns>
+        [Experimental(diagnosticId: "ST0007", UrlFormat = "https://dotnet.github.io/Silk.NET/docs/v3/silk.net/diagnostics/{0}")]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(T other) => value.Convert<T, ulong>() == other.Convert<T, ulong>();
+
+        /// <summary>
+        /// Compares two values of differing types for numeric equality
+        /// Types must be no larger than 8 bytes.
+        /// </summary>
+        /// <param name="right"></param>
+        /// <typeparam name="T2"></typeparam>
+        /// <returns></returns>
+        [Experimental(diagnosticId: "ST0008", UrlFormat = "https://dotnet.github.io/Silk.NET/docs/v3/silk.net/diagnostics/{0}")]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals<T2>(T2 right) where T2 : unmanaged => value.Convert<T, ulong>() == right.Convert<T2, ulong>();
+
+        /// <summary>
+        /// Returns the numerical value of the enum value provided in a type-safe way
+        /// </summary>
+        /// <typeparam name="TTo"></typeparam>
+        /// <returns></returns>
+        [Experimental(diagnosticId: "ST0009", UrlFormat = "https://dotnet.github.io/Silk.NET/docs/v3/silk.net/diagnostics/{0}")]
+        internal unsafe TTo Convert<TTo>() where TTo : unmanaged
+        {
+            if (sizeof(T) == sizeof(TTo))
+            {
+                return Unsafe.Read<TTo>(&value);
+            }
+
+            var minSize = Math.Min(sizeof(TTo), sizeof(T));
+
+            var originalValuePtr = (byte*)&value;
+
+            var valuePtr = &originalValuePtr[Math.Abs(minSize - sizeof(T))]; // todo: does this assume little-endianness?
+            var numberPtr = stackalloc byte[sizeof(TTo)];
+
+            // ensure block is initialized (as it isnt guaranteed?) so any missing bytes of the output will stay 0
+            // if type TNumber is a larger size than type T
+            Unsafe.InitBlock(numberPtr, 0, (uint)sizeof(TTo));
+
+            var copyToPtr = &numberPtr[Math.Abs(minSize - sizeof(TTo))];
+            Buffer.MemoryCopy(valuePtr, copyToPtr, sizeof(TTo), minSize);
+            return *(TTo*)numberPtr;
+        }
+    }
+}