public RowEnumerator(ReadOnlySpan <char> str, ParseRowFunc <T> parseRowFunc, char rowSeparator = '\n', char columnSeparator = ',')
{
rowsEnumerator = str.FastSplit(rowSeparator);
this.parseRowFunc = parseRowFunc;
this.columnSeparator = columnSeparator;
Current = default;
rowIndex = 0;
}
public static List <string> ConvertStringList(this SplitEnumerator typeEnumerator, int count)
{
List <string> list = new(count);
foreach (ReadOnlySpan <char> span in typeEnumerator)
{
list.Add(span.ToString());
}
return(list);
}
public static List <short> ConvertInt16List(this SplitEnumerator typeEnumerator, int count)
{
List <short> list = new(count);
foreach (ReadOnlySpan <char> span in typeEnumerator)
{
list.Add(span.ParseInt16());
}
return(list);
}
public static List <decimal> ConvertDecimalList(this SplitEnumerator typeEnumerator, int count)
{
List <decimal> list = new(count);
foreach (ReadOnlySpan <char> span in typeEnumerator)
{
list.Add(span.ParseDecimal());
}
return(list);
}
public static List <float> ConvertSingleList(this SplitEnumerator typeEnumerator, int count)
{
List <float> list = new(count);
foreach (ReadOnlySpan <char> span in typeEnumerator)
{
list.Add(span.ParseSingle());
}
return(list);
}
public static List <ulong> ConvertUInt64List(this SplitEnumerator typeEnumerator, int count)
{
List <ulong> list = new(count);
foreach (ReadOnlySpan <char> span in typeEnumerator)
{
list.Add(span.ParseUInt64());
}
return(list);
}
public static List <char> ConvertCharList(this SplitEnumerator typeEnumerator, int count)
{
List <char> list = new(count);
foreach (ReadOnlySpan <char> span in typeEnumerator)
{
list.Add(span[0]);
}
return(list);
}
public static ushort[] ConvertUInt16Array(this SplitEnumerator typeEnumerator, int count)
{
ushort[] array = new ushort[count];
int i = 0;
foreach (ReadOnlySpan <char> span in typeEnumerator)
{
array[i++] = span.ParseUInt16();
}
return(array);
}
public static string[] ConvertStringArray(this SplitEnumerator typeEnumerator, int count)
{
string[] array = new string[count];
int i = 0;
foreach (ReadOnlySpan <char> span in typeEnumerator)
{
array[i++] = span.ToString();
}
return(array);
}
public static char[] ConvertCharArray(this SplitEnumerator typeEnumerator, int count)
{
char[] array = new char[count];
int i = 0;
foreach (ReadOnlySpan <char> span in typeEnumerator)
{
array[i++] = span[0];
}
return(array);
}
public static float[] ConvertSingleArray(this SplitEnumerator typeEnumerator, int count)
{
float[] array = new float[count];
int i = 0;
foreach (ReadOnlySpan <char> span in typeEnumerator)
{
array[i++] = span.ParseSingle();
}
return(array);
}
public static long[] ConvertInt64Array(this SplitEnumerator typeEnumerator, int count)
{
long[] array = new long[count];
int i = 0;
foreach (ReadOnlySpan <char> span in typeEnumerator)
{
array[i++] = span.ParseInt64();
}
return(array);
}
public static byte[] ConvertByteArray(this SplitEnumerator typeEnumerator, int count)
{
byte[] array = new byte[count];
int i = 0;
foreach (ReadOnlySpan <char> span in typeEnumerator)
{
array[i++] = span.ParseByte();
}
return(array);
}
public static decimal[] ConvertDecimalArray(this SplitEnumerator typeEnumerator, int count)
{
decimal[] array = new decimal[count];
int i = 0;
foreach (ReadOnlySpan <char> span in typeEnumerator)
{
array[i++] = span.ParseDecimal();
}
return(array);
}
private static object CreateComplex(this Type propertyType, SplitEnumerator propertyNameEnumerator, SplitEnumerator valueEnumerator)
{
ObjectAccessor?semiAccessor = ObjectAccessor.Create(Activator.CreateInstance(propertyType) !);
ReadOnlyDictionary <string, Type> typeMap = TypeNameMap.GetOrCreate(propertyType);
foreach (ReadOnlySpan <char> readOnlySpan in valueEnumerator)
{
propertyNameEnumerator.MoveNext();
string currentName = propertyNameEnumerator.Current.ToString();
semiAccessor[currentName] = typeMap[currentName].ConvertSpan(readOnlySpan);
}
return(semiAccessor.Target !);
}
//****************************************
internal SplitSingleEnumerator(ReadOnlySpan <T> sequence, T separator, bool omitEmpty)
{
_Separator = separator;
// We can create a Span from an internal field safely here, since this is a Ref struct
_Enumerator = new SplitEnumerator <T>(sequence, default, omitEmpty);
public static object ConvertArray(this SplitEnumerator typeEnumerator, Type containedType, int count)
{
if (containedType == typeof(bool))
{
return(typeEnumerator.ConvertBoolArray(count));
}
if (containedType == typeof(byte))
{
return(typeEnumerator.ConvertByteArray(count));
}
if (containedType == typeof(sbyte))
{
return(typeEnumerator.ConvertSByteArray(count));
}
if (containedType == typeof(char))
{
return(typeEnumerator.ConvertCharArray(count));
}
if (containedType == typeof(decimal))
{
return(typeEnumerator.ConvertDecimalArray(count));
}
if (containedType == typeof(double))
{
return(typeEnumerator.ConvertDoubleArray(count));
}
if (containedType == typeof(float))
{
return(typeEnumerator.ConvertSingleArray(count));
}
if (containedType == typeof(int))
{
return(typeEnumerator.ConvertInt32Array(count));
}
if (containedType == typeof(uint))
{
return(typeEnumerator.ConvertUInt32Array(count));
}
if (containedType == typeof(long))
{
return(typeEnumerator.ConvertInt64Array(count));
}
if (containedType == typeof(ulong))
{
return(typeEnumerator.ConvertUInt64Array(count));
}
if (containedType == typeof(short))
{
return(typeEnumerator.ConvertInt16Array(count));
}
if (containedType == typeof(ushort))
{
return(typeEnumerator.ConvertUInt32Array(count));
}
if (containedType == typeof(string))
{
return(typeEnumerator.ConvertStringArray(count));
}
Array array = Array.CreateInstance(containedType, count);
int i = 0;
foreach (ReadOnlySpan <char> span in typeEnumerator)
{
array.SetValue(containedType.ConvertSpan(span), i++);
}
return(array);
}
public static object ConvertList(this SplitEnumerator typeEnumerator, Type containedType, Type collectionType, int count)
{
if (containedType == typeof(bool))
{
return(typeEnumerator.ConvertBoolList(count));
}
if (containedType == typeof(byte))
{
return(typeEnumerator.ConvertByteList(count));
}
if (containedType == typeof(sbyte))
{
return(typeEnumerator.ConvertSByteList(count));
}
if (containedType == typeof(char))
{
return(typeEnumerator.ConvertCharList(count));
}
if (containedType == typeof(decimal))
{
return(typeEnumerator.ConvertDecimalList(count));
}
if (containedType == typeof(double))
{
return(typeEnumerator.ConvertDoubleList(count));
}
if (containedType == typeof(float))
{
return(typeEnumerator.ConvertSingleList(count));
}
if (containedType == typeof(int))
{
return(typeEnumerator.ConvertInt32List(count));
}
if (containedType == typeof(uint))
{
return(typeEnumerator.ConvertUInt32List(count));
}
if (containedType == typeof(long))
{
return(typeEnumerator.ConvertInt64List(count));
}
if (containedType == typeof(ulong))
{
return(typeEnumerator.ConvertUInt64List(count));
}
if (containedType == typeof(short))
{
return(typeEnumerator.ConvertInt16List(count));
}
if (containedType == typeof(ushort))
{
return(typeEnumerator.ConvertUInt32List(count));
}
if (containedType == typeof(string))
{
return(typeEnumerator.ConvertStringList(count));
}
IList list = (IList)Activator.CreateInstance(collectionType, count) !;
foreach (ReadOnlySpan <char> span in typeEnumerator)
{
list.Add(containedType.ConvertSpan(span));
}
return(list);
}
