Replace DvText with .NET Standard type.

src/Microsoft.ML.Api/ApiUtils.cs

@@ -20,7 +20,7 @@ private static OpCode GetAssignmentOpCode(Type t)
             // REVIEW: This should be a Dictionary<Type, OpCode> based solution.
             // DvTypes, strings, arrays, all nullable types, VBuffers and UInt128.
             if (t == typeof(DvInt8) || t == typeof(DvInt4) || t == typeof(DvInt2) || t == typeof(DvInt1) ||
-                t == typeof(DvBool) || t == typeof(DvText) || t == typeof(string) || t.IsArray ||
+                t == typeof(DvBool) || t == typeof(ReadOnlyMemory<char>) || t == typeof(string) || t.IsArray ||
                 (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(VBuffer<>)) ||
                 (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>)) ||
                 t == typeof(DvDateTime) || t == typeof(DvDateTimeZone) || t == typeof(DvTimeSpan) || t == typeof(UInt128))

src/Microsoft.ML.Api/DataViewConstructionUtils.cs

@@ -125,11 +125,11 @@ private Delegate CreateGetter(int index)
                     if (outputType.IsArray)
                     {
                         Ch.Assert(colType.IsVector);
-                        // String[] -> VBuffer<DvText>
+                        // String[] -> ReadOnlyMemory<char>
                         if (outputType.GetElementType() == typeof(string))
                         {
                             Ch.Assert(colType.ItemType.IsText);
-                            return CreateConvertingArrayGetterDelegate<String, DvText>(index, x => x == null ? DvText.NA : new DvText(x));
+                            return CreateConvertingArrayGetterDelegate<string, ReadOnlyMemory<char>>(index, x =>  x != null ? x.AsMemory() : "".AsMemory() );
                         }
                         else if (outputType.GetElementType() == typeof(int))
                         {
@@ -193,7 +193,7 @@ private Delegate CreateGetter(int index)
                     else if (colType.IsVector)
                     {
                         // VBuffer<T> -> VBuffer<T>
-                        // REVIEW: Do we care about accomodating VBuffer<string> -> VBuffer<DvText>?
+                        // REVIEW: Do we care about accomodating VBuffer<string> -> ReadOnlyMemory<char>?
                         Ch.Assert(outputType.IsGenericType);
                         Ch.Assert(outputType.GetGenericTypeDefinition() == typeof(VBuffer<>));
                         Ch.Assert(outputType.GetGenericArguments()[0] == colType.ItemType.RawType);
@@ -204,9 +204,9 @@ private Delegate CreateGetter(int index)
                     {
                         if (outputType == typeof(string))
                         {
-                            // String -> DvText
+                            // String -> ReadOnlyMemory<char>
                             Ch.Assert(colType.IsText);
-                            return CreateConvertingGetterDelegate<String, DvText>(index, x => x == null ? DvText.NA : new DvText(x));
+                            return CreateConvertingGetterDelegate<String, ReadOnlyMemory<char>>(index, x => x != null ? x.AsMemory() : "".AsMemory());
                         }
                         else if (outputType == typeof(bool))
                         {
@@ -805,12 +805,12 @@ public override ValueGetter<TDst> GetGetter<TDst>()
                 var itemType = typeT.GetElementType();
                 var dstItemType = typeof(TDst).GetGenericArguments()[0];
 
-                // String[] -> VBuffer<DvText>
+                // String[] -> VBuffer<ReadOnlyMemory<char>>
                 if (itemType == typeof(string))
                 {
-                    Contracts.Check(dstItemType == typeof(DvText));
+                    Contracts.Check(dstItemType == typeof(ReadOnlyMemory<char>));
 
-                    ValueGetter<VBuffer<DvText>> method = GetStringArray;
+                    ValueGetter<VBuffer<ReadOnlyMemory<char>>> method = GetStringArray;
                     return method as ValueGetter<TDst>;
                 }
 
@@ -825,7 +825,7 @@ public override ValueGetter<TDst> GetGetter<TDst>()
             if (MetadataType.IsVector)
             {
                 // VBuffer<T> -> VBuffer<T>
-                // REVIEW: Do we care about accomodating VBuffer<string> -> VBuffer<DvText>?
+                // REVIEW: Do we care about accomodating VBuffer<string> -> VBuffer<ReadOnlyMemory<char>>?
 
                 Contracts.Assert(typeT.IsGenericType);
                 Contracts.Check(typeof(TDst).IsGenericType);
@@ -845,9 +845,9 @@ public override ValueGetter<TDst> GetGetter<TDst>()
             {
                 if (typeT == typeof(string))
                 {
-                    // String -> DvText
+                    // String -> ReadOnlyMemory<char>
                     Contracts.Assert(MetadataType.IsText);
-                    ValueGetter<DvText> m = GetString;
+                    ValueGetter<ReadOnlyMemory<char>> m = GetString;
                     return m as ValueGetter<TDst>;
                 }
                 // T -> T
@@ -861,14 +861,14 @@ public class TElement
         {
         }
 
-        private void GetStringArray(ref VBuffer<DvText> dst)
+        private void GetStringArray(ref VBuffer<ReadOnlyMemory<char>> dst)
         {
             var value = (string[])(object)Value;
             var n = Utils.Size(value);
-            dst = new VBuffer<DvText>(n, Utils.Size(dst.Values) < n ? new DvText[n] : dst.Values, dst.Indices);
+            dst = new VBuffer<ReadOnlyMemory<char>>(n, Utils.Size(dst.Values) < n ? new ReadOnlyMemory<char>[n] : dst.Values, dst.Indices);
 
             for (int i = 0; i < n; i++)
-                dst.Values[i] = new DvText(value[i]);
+                dst.Values[i] = value[i].AsMemory();
 
         }
 
@@ -890,9 +890,9 @@ private ValueGetter<VBuffer<TDst>> GetVBufferGetter<TDst>()
             return (ref VBuffer<TDst> dst) => castValue.CopyTo(ref dst);
         }
 
-        private void GetString(ref DvText dst)
+        private void GetString(ref ReadOnlyMemory<char> dst)
         {
-            dst = new DvText((string)(object)Value);
+            dst = ((string)(object)Value).AsMemory();
         }
 
         private void GetDirectValue<TDst>(ref TDst dst)

src/Microsoft.ML.Api/Microsoft.ML.Api.csproj

@@ -15,6 +15,7 @@
 
   <ItemGroup>
      <PackageReference Include="System.CodeDom" Version="$(SystemCodeDomPackageVersion)" />
+     <PackageReference Include="System.Memory" Version="4.5.1" />
      <PackageReference Include="System.Reflection.Emit.Lightweight" Version="$(SystemReflectionEmitLightweightPackageVersion)" />
   </ItemGroup>
 

src/Microsoft.ML.Api/TypedCursor.cs

@@ -276,11 +276,11 @@ private Action<TRow> GenerateSetter(IRow input, int index, InternalSchemaDefinit
                 if (fieldType.IsArray)
                 {
                     Ch.Assert(colType.IsVector);
-                    // VBuffer<DvText> -> String[]
+                    // VBuffer<ReadOnlyMemory<char>> -> String[]
                     if (fieldType.GetElementType() == typeof(string))
                     {
                         Ch.Assert(colType.ItemType.IsText);
-                        return CreateConvertingVBufferSetter<DvText, string>(input, index, poke, peek, x => x.ToString());
+                        return CreateConvertingVBufferSetter<ReadOnlyMemory<char>, string>(input, index, poke, peek, x => x.ToString());
                     }
                     else if (fieldType.GetElementType() == typeof(bool))
                     {
@@ -344,7 +344,7 @@ private Action<TRow> GenerateSetter(IRow input, int index, InternalSchemaDefinit
                 else if (colType.IsVector)
                 {
                     // VBuffer<T> -> VBuffer<T>
-                    // REVIEW: Do we care about accomodating VBuffer<string> -> VBuffer<DvText>?
+                    // REVIEW: Do we care about accomodating VBuffer<string> -> VBuffer<ReadOnlyMemory<char>>?
                     Ch.Assert(fieldType.IsGenericType);
                     Ch.Assert(fieldType.GetGenericTypeDefinition() == typeof(VBuffer<>));
                     Ch.Assert(fieldType.GetGenericArguments()[0] == colType.ItemType.RawType);
@@ -355,10 +355,10 @@ private Action<TRow> GenerateSetter(IRow input, int index, InternalSchemaDefinit
                 {
                     if (fieldType == typeof(string))
                     {
-                        // DvText -> String
+                        // ReadOnlyMemory<char> -> String
                         Ch.Assert(colType.IsText);
                         Ch.Assert(peek == null);
-                        return CreateConvertingActionSetter<DvText, string>(input, index, poke, x => x.ToString());
+                        return CreateConvertingActionSetter<ReadOnlyMemory<char>, string>(input, index, poke, x => x.ToString());
                     }
                     else if (fieldType == typeof(bool))
                     {

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

@@ -341,7 +341,7 @@ public static TextType Instance
         }
 
         private TextType()
-            : base(typeof(DvText), DataKind.TX)
+            : base(typeof(ReadOnlyMemory<char>), DataKind.TX)
         {
         }
 

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

@@ -161,7 +161,7 @@ public static Type ToType(this DataKind kind)
                 case DataKind.R8:
                     return typeof(Double);
                 case DataKind.TX:
-                    return typeof(DvText);
+                    return typeof(ReadOnlyMemory<char>);
                 case DataKind.BL:
                     return typeof(DvBool);
                 case DataKind.TS:
@@ -205,7 +205,7 @@ public static bool TryGetDataKind(this Type type, out DataKind kind)
                 kind = DataKind.R4;
             else if (type == typeof(Double)|| type == typeof(Double?))
                 kind = DataKind.R8;
-            else if (type == typeof(DvText))
+            else if (type == typeof(ReadOnlyMemory<char>) || type == typeof(string))
                 kind = DataKind.TX;
             else if (type == typeof(DvBool) || type == typeof(bool) || type == typeof(bool?))
                 kind = DataKind.BL;