public static VecValueMap <TVal> CreateVector <TVal>(VectorType type)
{
Contracts.AssertValue(type);
Contracts.Assert(type.ItemType.RawType == typeof(TVal));
return(new VecValueMap <TVal>(type));
}
public VecValueMap(VectorType type)
: base(type)
{
}
private LabelNameBindableMapper(IHostEnvironment env, ISchemaBoundMapper mapper, VectorType type, Delegate getter,
string metadataKind, Func <ISchemaBoundMapper, ColumnType, bool> canWrap)
: this(env, mapper.Bindable, type, getter, metadataKind, canWrap)
{
}
/// <summary>
/// Append label names to score column as its metadata.
/// </summary>
private Schema DecorateOutputSchema(Schema partialSchema, int scoreColumnIndex, VectorType labelNameType,
ValueGetter <VBuffer <T> > labelNameGetter, string labelNameKind)
{
var builder = new SchemaBuilder();
// Sequentially add columns so that the order of them is not changed comparing with the schema in the mapper
// that computes score column.
for (int i = 0; i < partialSchema.Count; ++i)
{
var meta = new MetadataBuilder();
if (i == scoreColumnIndex)
{
// Add label names for score column.
meta.Add(partialSchema[i].Metadata, selector: s => s != labelNameKind);
meta.Add(labelNameKind, labelNameType, labelNameGetter);
}
else
{
// Copy all existing metadata because this transform only affects score column.
meta.Add(partialSchema[i].Metadata, selector: s => true);
}
// Instead of appending extra metadata to the existing score column, we create new one because
// metadata is read-only.
builder.AddColumn(partialSchema[i].Name, partialSchema[i].Type, meta.GetMetadata());
}
return(builder.GetSchema());
}
internal static ISchemaBoundMapper CreateBound <T>(IHostEnvironment env, ISchemaBoundRowMapper mapper, VectorType type, Delegate getter,
string metadataKind, Func <ISchemaBoundMapper, ColumnType, bool> canWrap)
{
Contracts.AssertValue(env);
env.AssertValue(mapper);
env.AssertValue(type);
env.AssertValue(getter);
env.Assert(getter is ValueGetter <VBuffer <T> >);
env.AssertNonEmpty(metadataKind);
env.AssertValueOrNull(canWrap);
return(new Bound <T>(env, mapper, type, (ValueGetter <VBuffer <T> >)getter, metadataKind, canWrap));
}
private LabelNameBindableMapper(IHostEnvironment env, ISchemaBindableMapper bindable, VectorType type, Delegate getter,
string metadataKind, Func <ISchemaBoundMapper, ColumnType, bool> canWrap)
{
Contracts.AssertValue(env);
_host = env.Register(LoaderSignature);
_host.AssertValue(bindable);
_host.AssertValue(type);
_host.AssertValue(getter);
_host.AssertNonEmpty(metadataKind);
_host.AssertValueOrNull(canWrap);
_bindable = bindable;
_type = type;
_getter = getter;
_metadataKind = metadataKind;
_canWrap = canWrap;
}
private static bool TryCreateEx(IExceptionContext ectx, ColInfo info, DataKind kind, KeyRange range, out PrimitiveType itemType, out ColInfoEx ex)
{
ectx.AssertValue(info);
ectx.Assert(Enum.IsDefined(typeof(DataKind), kind));
ex = null;
var typeSrc = info.TypeSrc;
if (range != null)
{
itemType = TypeParsingUtils.ConstructKeyType(kind, range);
if (!typeSrc.ItemType.IsKey && !typeSrc.ItemType.IsText)
{
return(false);
}
}
else if (!typeSrc.ItemType.IsKey)
{
itemType = PrimitiveType.FromKind(kind);
}
else if (!KeyType.IsValidDataKind(kind))
{
itemType = PrimitiveType.FromKind(kind);
return(false);
}
else
{
var key = typeSrc.ItemType.AsKey;
ectx.Assert(KeyType.IsValidDataKind(key.RawKind));
int count = key.Count;
// Technically, it's an error for the counts not to match, but we'll let the Conversions
// code return false below. There's a possibility we'll change the standard conversions to
// map out of bounds values to zero, in which case, this is the right thing to do.
ulong max = kind.ToMaxInt();
if ((ulong)count > max)
{
count = (int)max;
}
itemType = new KeyType(kind, key.Min, count, key.Contiguous);
}
// Ensure that the conversion is legal. We don't actually cache the delegate here. It will get
// re-fetched by the utils code when needed.
bool identity;
Delegate del;
if (!Conversions.Instance.TryGetStandardConversion(typeSrc.ItemType, itemType, out del, out identity))
{
return(false);
}
ColumnType typeDst = itemType;
if (typeSrc.IsVector)
{
typeDst = new VectorType(itemType, typeSrc.AsVector);
}
// An output column is transposable iff the input column was transposable.
VectorType slotType = null;
if (info.SlotTypeSrc != null)
{
slotType = new VectorType(itemType, info.SlotTypeSrc);
}
ex = new ColInfoEx(kind, range != null, typeDst, slotType);
return(true);
}