protected override bool TryParse(string str)
{
Contracts.AssertNonEmpty(str);
// We accept N:T:S where N is the new column name, T is the new type,
// and S is source column names.
string extra;
if (!base.TryParse(str, out extra))
{
return(false);
}
if (extra == null)
{
return(true);
}
InternalDataKind kind;
if (!TypeParsingUtils.TryParseDataKind(extra, out kind, out KeyCount))
{
return(false);
}
ResultType = InternalDataKind2DataKind(kind);
return(true);
}
public static bool TryParse(string str, out Column column)
{
column = null;
if (string.IsNullOrEmpty(str))
{
return(false);
}
if (!ColumnParsingUtils.TryParse(str, out string name, out string sourceStr, out string kindStr))
{
return(false);
}
DataKind?kind = null;
if (kindStr != null && TypeParsingUtils.TryParseDataKind(kindStr, out DataKind parsedKind, out KeyRange range))
{
kind = parsedKind;
}
if (!int.TryParse(sourceStr, out int source))
{
return(false);
}
column = new Column()
{
Name = name,
Source = source,
Type = kind
};
return(true);
}
/// <summary>
/// Construct a <see cref="KeyType"/> out of the data kind and the key range.
/// </summary>
public static KeyType ConstructKeyType(DataKind?type, KeyRange range)
{
Contracts.CheckValue(range, nameof(range));
DataKind kind;
KeyType keyType;
kind = type ?? DataKind.U4;
Contracts.CheckUserArg(KeyType.IsValidDataKind(kind), nameof(TextLoader.Column.Type), "Bad item type for Key");
Contracts.CheckUserArg(range.Min >= 0, nameof(range.Min), "min must be non-negative");
if (range.Max == null)
{
keyType = new KeyType(kind, range.Min, 0, range.Contiguous);
}
else
{
Contracts.CheckUserArg(range.Contiguous, nameof(range.Max), "max must be null when contiguous is false");
ulong max = range.Max.GetValueOrDefault();
Contracts.CheckUserArg(max >= range.Min, nameof(range.Max), "max must be >= min");
Contracts.CheckUserArg(max - range.Min < int.MaxValue, nameof(range.Max), "range is too large");
int count = (int)(max - range.Min + 1);
Contracts.Assert(count >= 1);
if ((ulong)count > kind.ToMaxInt())
{
throw Contracts.ExceptUserArg(nameof(range.Max), "range is too large for type {0}", kind);
}
keyType = new KeyType(kind, range.Min, count);
}
return(keyType);
}
public Column(string name, ColumnPurpose purpose, DataKind?dataKind, string ranges)
{
Contracts.CheckValue(name, nameof(name));
Contracts.CheckValue(ranges, nameof(ranges));
_name = name;
ColumnPurpose = purpose;
Kind = dataKind;
Indices = ColumnGroupingInference.GetRange(ranges);
}
private protected override bool TryParse(string str)
{
Contracts.AssertNonEmpty(str);
// We accept N:T:S where N is the new column name, T is the new type,
// and S is source column names.
if (!base.TryParse(str, out string extra))
return false;
if (extra == null)
return true;
if (!TypeParsingUtils.TryParseDataKind(extra, out DataKind kind, out KeyCount))
return false;
ResultType = kind == default ? default(DataKind?) : kind;
return true;
}
/// <summary>
/// Construct a <see cref="KeyType"/> out of the data kind and the keyCount.
/// </summary>
public static KeyType ConstructKeyType(DataKind?type, KeyCount keyCount)
{
Contracts.CheckValue(keyCount, nameof(keyCount));
KeyType keyType;
Type rawType = type.HasValue ? type.Value.ToType() : DataKind.U8.ToType();
Contracts.CheckUserArg(KeyType.IsValidDataType(rawType), nameof(TextLoader.Column.Type), "Bad item type for Key");
if (keyCount.Count == null)
{
keyType = new KeyType(rawType, rawType.ToMaxInt());
}
else
{
keyType = new KeyType(rawType, keyCount.Count.GetValueOrDefault());
}
return(keyType);
}
public PredictedColumn(string columnName, bool isAlphanumeric = false, DataKind?dataKind = null)
{
ColumnName = columnName;
IsAlphanumeric = isAlphanumeric;
DataKind = dataKind;
}