Remove the rest of RawKind usages in Conversions.

Author: eerhardt

src/Microsoft.ML.Core/Data/DataKind.cs

@@ -104,6 +104,32 @@ public static ulong ToMaxInt(this DataKind kind)
             return 0;
         }
 
+        /// <summary>
+        /// For integer DataKinds, this returns the maximum legal value. For un-supported kinds,
+        /// it returns zero.
+        /// </summary>
+        public static ulong ToMaxInt(this Type type)
+        {
+            if (type == typeof(sbyte))
+                return (ulong)sbyte.MaxValue;
+            else if (type == typeof(byte))
+                return byte.MaxValue;
+            else if (type == typeof(short))
+                return (ulong)short.MaxValue;
+            else if (type == typeof(ushort))
+                return ushort.MaxValue;
+            else if (type == typeof(int))
+                return int.MaxValue;
+            else if (type == typeof(uint))
+                return uint.MaxValue;
+            else if (type == typeof(long))
+                return long.MaxValue;
+            else if (type == typeof(ulong))
+                return ulong.MaxValue;
+
+            return 0;
+        }
+
         /// <summary>
         /// For integer DataKinds, this returns the minimum legal value. For un-supported kinds,
         /// it returns one.

src/Microsoft.ML.Data/Data/Conversion.cs

@@ -8,6 +8,7 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Reflection;
+using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading;
 using Microsoft.ML.Internal.Utilities;
@@ -394,7 +395,7 @@ public bool TryGetStandardConversion(ColumnType typeSrc, ColumnType typeDst,
                     // Smaller dst means mapping values to NA.
                     if (keySrc.Count != keyDst.Count)
                         return false;
-                    if (keySrc.Count == 0 && keySrc.RawKind > keyDst.RawKind)
+                    if (keySrc.Count == 0 && Marshal.SizeOf(keySrc.RawType) > Marshal.SizeOf(keyDst.RawType))
                         return false;
                     // REVIEW: Should we allow contiguous to be changed when Count is zero?
                     if (keySrc.Contiguous != keyDst.Contiguous)
@@ -407,11 +408,11 @@ public bool TryGetStandardConversion(ColumnType typeSrc, ColumnType typeDst,
                     // does not allow this.
                     if (!KeyType.IsValidDataType(typeDst.RawType))
                         return false;
-                    if (keySrc.RawKind > typeDst.RawKind)
+                    if (Marshal.SizeOf(keySrc.RawType) > Marshal.SizeOf(typeDst.RawType))
                     {
                         if (keySrc.Count == 0)
                             return false;
-                        if ((ulong)keySrc.Count > typeDst.RawKind.ToMaxInt())
+                        if ((ulong)keySrc.Count > typeDst.RawType.ToMaxInt())
                             return false;
                     }
                 }
@@ -549,20 +550,19 @@ private TryParseMapper<TDst> GetKeyTryParse<TDst>(KeyType key)
             ulong min = key.Min;
             ulong max;
 
-            ulong count = DataKindExtensions.ToMaxInt(key.RawKind);
+            ulong count = key.RawType.ToMaxInt();
             if (key.Count > 0)
                 max = min - 1 + (ulong)key.Count;
             else if (min == 0)
                 max = count - 1;
-            else if (key.RawKind == DataKind.U8)
+            else if (key.RawType == typeof(ulong))
                 max = ulong.MaxValue;
             else if (min - 1 > ulong.MaxValue - count)
                 max = ulong.MaxValue;
             else
                 max = min - 1 + count;
 
-            bool identity;
-            var fnConv = GetStandardConversion<U8, TDst>(NumberType.U8, NumberType.FromKind(key.RawKind), out identity);
+            var fnConv = GetKeyStandardConversion<TDst>();
             return
                 (in TX src, out TDst dst) =>
                 {
@@ -592,20 +592,19 @@ private ValueMapper<TX, TDst> GetKeyParse<TDst>(KeyType key)
             ulong min = key.Min;
             ulong max;
 
-            ulong count = DataKindExtensions.ToMaxInt(key.RawKind);
+            ulong count = key.RawType.ToMaxInt();
             if (key.Count > 0)
                 max = min - 1 + (ulong)key.Count;
             else if (min == 0)
                 max = count - 1;
-            else if (key.RawKind == DataKind.U8)
+            else if (key.RawType == typeof(U8))
                 max = ulong.MaxValue;
             else if (min - 1 > ulong.MaxValue - count)
                 max = ulong.MaxValue;
             else
                 max = min - 1 + count;
 
-            bool identity;
-            var fnConv = GetStandardConversion<U8, TDst>(NumberType.U8, NumberType.FromKind(key.RawKind), out identity);
+            var fnConv = GetKeyStandardConversion<TDst>();
             return
                 (in TX src, ref TDst dst) =>
                 {
@@ -622,6 +621,14 @@ private ValueMapper<TX, TDst> GetKeyParse<TDst>(KeyType key)
                 };
         }
 
+        private ValueMapper<U8, TDst> GetKeyStandardConversion<TDst>()
+        {
+            var delegatesKey = (typeof(U8), typeof(TDst));
+            if (!_delegatesStd.TryGetValue(delegatesKey, out Delegate del))
+                throw Contracts.Except("No standard conversion from '{0}' to '{1}'", typeof(U8), typeof(TDst));
+            return (ValueMapper<U8, TDst>)del;
+        }
+
         private static StringBuilder ClearDst(ref StringBuilder dst)
         {
             if (dst == null)