internal virtual void PredictionEngineCore(IHostEnvironment env, DataViewConstructionUtils.InputRow <TSrc> inputRow, IRowToRowMapper mapper, bool ignoreMissingColumns,
SchemaDefinition inputSchemaDefinition, SchemaDefinition outputSchemaDefinition, out Action disposer, out IRowReadableAs <TDst> outputRow)
{
var cursorable = TypedCursorable <TDst> .Create(env, new EmptyDataView(env, mapper.Schema), ignoreMissingColumns, outputSchemaDefinition);
var outputRowLocal = mapper.GetRow(_inputRow, col => true, out disposer);
outputRow = cursorable.GetRow(outputRowLocal);
}
/// <summary>
/// Generate a strongly-typed cursorable wrapper of the <see cref="IDataView"/>.
/// </summary>
/// <typeparam name="TRow">The user-defined row type.</typeparam>
/// <param name="data">The underlying data view.</param>
/// <param name="env">The environment.</param>
/// <param name="ignoreMissingColumns">Whether to ignore the case when a requested column is not present in the data view.</param>
/// <param name="schemaDefinition">Optional user-provided schema definition. If it is not present, the schema is inferred from the definition of T.</param>
/// <returns>The cursorable wrapper of <paramref name="data"/>.</returns>
public static ICursorable <TRow> AsCursorable <TRow>(this IDataView data, IHostEnvironment env, bool ignoreMissingColumns = false,
SchemaDefinition schemaDefinition = null)
where TRow : class, new()
{
Contracts.CheckValue(env, nameof(env));
env.CheckValue(data, nameof(data));
env.CheckValueOrNull(schemaDefinition);
return(TypedCursorable <TRow> .Create(env, data, ignoreMissingColumns, schemaDefinition));
}
/// <summary>
/// The 'reapply' constructor.
/// </summary>
private StatefulFilterTransform(IHostEnvironment env, StatefulFilterTransform <TSrc, TDst, TState> transform, IDataView newSource)
: base(env, RegistrationName, transform)
{
Host.AssertValue(transform);
Host.AssertValue(newSource);
_source = newSource;
_filterFunc = transform._filterFunc;
_typedSource = TypedCursorable <TSrc> .Create(Host, newSource, false, transform._inputSchemaDefinition);
_schema = MergedSchema.Create(newSource.Schema, transform._schema.AddedSchema);
}
/// <summary>
/// The 'reapply' constructor.
/// </summary>
private StatefulFilterTransform(IHostEnvironment env, StatefulFilterTransform <TSrc, TDst, TState> transform, IDataView newSource)
: base(env, RegistrationName, transform)
{
Host.AssertValue(transform);
Host.AssertValue(newSource);
_source = newSource;
_filterFunc = transform._filterFunc;
_typedSource = TypedCursorable <TSrc> .Create(Host, newSource, false, transform._inputSchemaDefinition);
_addedSchema = transform._addedSchema;
_bindings = new ColumnBindings(Schema.Create(newSource.Schema), DataViewConstructionUtils.GetSchemaColumns(_addedSchema));
}
/// <summary>
/// The 'reapply' constructor.
/// </summary>
private MapTransform(IHostEnvironment env, MapTransform <TSrc, TDst> transform, IDataView newSource)
: base(env, RegistrationName, transform)
{
Host.AssertValue(transform);
Host.AssertValue(newSource);
_source = newSource;
_mapAction = transform._mapAction;
_typedSource = TypedCursorable <TSrc> .Create(Host, newSource, false, transform._inputSchemaDefinition);
_schema = MergedSchema.Create(newSource.Schema, transform._schema.AddedSchema);
}
/// <summary>
/// The 'reapply' constructor.
/// </summary>
private MapTransform(IHostEnvironment env, MapTransform <TSrc, TDst> transform, IDataView newSource)
: base(env, RegistrationName, transform)
{
Host.AssertValue(transform);
Host.AssertValue(newSource);
Source = newSource;
_mapAction = transform._mapAction;
_typedSource = TypedCursorable <TSrc> .Create(Host, newSource, false, transform._inputSchemaDefinition);
_addedSchema = transform._addedSchema;
_bindings = new ColumnBindings(Data.Schema.Create(newSource.Schema), DataViewConstructionUtils.GetSchemaColumns(_addedSchema));
}
private PredictionEngine(IHostEnvironment env, Func <ISchema, IRowToRowMapper> makeMapper, bool ignoreMissingColumns,
SchemaDefinition inputSchemaDefinition, SchemaDefinition outputSchemaDefinition)
{
Contracts.CheckValue(env, nameof(env));
env.AssertValue(makeMapper);
_inputRow = DataViewConstructionUtils.CreateInputRow <TSrc>(env, inputSchemaDefinition);
var mapper = makeMapper(_inputRow.Schema);
var cursorable = TypedCursorable <TDst> .Create(env, new EmptyDataView(env, mapper.Schema), ignoreMissingColumns, outputSchemaDefinition);
var outputRow = mapper.GetRow(_inputRow, col => true, out _disposer);
_outputRow = cursorable.GetRow(outputRow);
}
public TypedRowBase(TypedCursorable <TRow> parent, Row input, string channelMessage)
: base(input)
{
Contracts.AssertValue(parent);
Contracts.AssertValue(parent._host);
Ch = parent._host.Start(channelMessage);
Ch.AssertValue(input);
int n = parent._pokes.Length;
Ch.Assert(n == parent._columns.Length);
Ch.Assert(n == parent._columnIndices.Length);
_setters = new Action <TRow> [n];
for (int i = 0; i < n; i++)
{
_setters[i] = GenerateSetter(Input, parent._columnIndices[i], parent._columns[i], parent._pokes[i], parent._peeks[i]);
}
}
/// <summary>
/// Create a a map transform that is savable iff <paramref name="saveAction"/> and <paramref name="loadFunc"/> are
/// not null.
/// </summary>
/// <param name="env">The host environment</param>
/// <param name="source">The dataview upon which we construct the transform</param>
/// <param name="mapAction">The action by which we map source to destination columns</param>
/// <param name="saveAction">An action that allows us to save state to the serialization stream. May be
/// null simultaneously with <paramref name="loadFunc"/>.</param>
/// <param name="loadFunc">A function that given the serialization stream and a data view, returns
/// an <see cref="ITransformTemplate"/>. The intent is, this returned object should itself be a
/// <see cref="MapTransform{TSrc,TDst}"/>, but this is not strictly necessary. This delegate should be
/// a static non-lambda method that this assembly can legally call. May be null simultaneously with
/// <paramref name="saveAction"/>.</param>
/// <param name="inputSchemaDefinition">The schema definition overrides for <typeparamref name="TSrc"/></param>
/// <param name="outputSchemaDefinition">The schema definition overrides for <typeparamref name="TDst"/></param>
public MapTransform(IHostEnvironment env, IDataView source, Action <TSrc, TDst> mapAction,
Action <BinaryWriter> saveAction, LambdaTransform.LoadDelegate loadFunc,
SchemaDefinition inputSchemaDefinition = null, SchemaDefinition outputSchemaDefinition = null)
: base(env, RegistrationName, saveAction, loadFunc)
{
Host.AssertValue(source, "source");
Host.AssertValue(mapAction, "mapAction");
Host.AssertValueOrNull(inputSchemaDefinition);
Host.AssertValueOrNull(outputSchemaDefinition);
_source = source;
_mapAction = mapAction;
_inputSchemaDefinition = inputSchemaDefinition;
_typedSource = TypedCursorable <TSrc> .Create(Host, Source, false, inputSchemaDefinition);
var outSchema = InternalSchemaDefinition.Create(typeof(TDst), outputSchemaDefinition);
_schema = MergedSchema.Create(_source.Schema, outSchema);
}
/// <summary>
/// Create a a map transform that is savable iff <paramref name="saveAction"/> and <paramref name="loadFunc"/> are
/// not null.
/// </summary>
/// <param name="env">The host environment</param>
/// <param name="source">The dataview upon which we construct the transform</param>
/// <param name="mapAction">The action by which we map source to destination columns</param>
/// <param name="saveAction">An action that allows us to save state to the serialization stream. May be
/// null simultaneously with <paramref name="loadFunc"/>.</param>
/// <param name="loadFunc">A function that given the serialization stream and a data view, returns
/// an <see cref="ITransformTemplate"/>. The intent is, this returned object should itself be a
/// <see cref="MapTransform{TSrc,TDst}"/>, but this is not strictly necessary. This delegate should be
/// a static non-lambda method that this assembly can legally call. May be null simultaneously with
/// <paramref name="saveAction"/>.</param>
/// <param name="inputSchemaDefinition">The schema definition overrides for <typeparamref name="TSrc"/></param>
/// <param name="outputSchemaDefinition">The schema definition overrides for <typeparamref name="TDst"/></param>
public MapTransform(IHostEnvironment env, IDataView source, Action <TSrc, TDst> mapAction,
Action <BinaryWriter> saveAction, LambdaTransform.LoadDelegate loadFunc,
SchemaDefinition inputSchemaDefinition = null, SchemaDefinition outputSchemaDefinition = null)
: base(env, RegistrationName, saveAction, loadFunc)
{
Host.AssertValue(source);
Host.AssertValue(mapAction);
Host.AssertValueOrNull(inputSchemaDefinition);
Host.AssertValueOrNull(outputSchemaDefinition);
Source = source;
_mapAction = mapAction;
_inputSchemaDefinition = inputSchemaDefinition;
_typedSource = TypedCursorable <TSrc> .Create(Host, Source, false, inputSchemaDefinition);
var outSchema = outputSchemaDefinition == null
? InternalSchemaDefinition.Create(typeof(TDst), SchemaDefinition.Direction.Write)
: InternalSchemaDefinition.Create(typeof(TDst), outputSchemaDefinition);
_addedSchema = outSchema;
_bindings = new ColumnBindings(Data.Schema.Create(Source.Schema), DataViewConstructionUtils.GetSchemaColumns(outSchema));
}
/// <summary>
/// Create a filter transform that is savable iff <paramref name="saveAction"/> and <paramref name="loadFunc"/> are
/// not null.
/// </summary>
/// <param name="env">The host environment</param>
/// <param name="source">The dataview upon which we construct the transform</param>
/// <param name="filterFunc">The function by which we transform source to destination columns and decide whether
/// to keep the row.</param>
/// <param name="initStateAction">The function that is called once per cursor to initialize state. Can be null.</param>
/// <param name="saveAction">An action that allows us to save state to the serialization stream. May be
/// null simultaneously with <paramref name="loadFunc"/>.</param>
/// <param name="loadFunc">A function that given the serialization stream and a data view, returns
/// an <see cref="ITransformTemplate"/>. The intent is, this returned object should itself be a
/// <see cref="CustomMappingTransformer{TSrc,TDst}"/>, but this is not strictly necessary. This delegate should be
/// a static non-lambda method that this assembly can legally call. May be null simultaneously with
/// <paramref name="saveAction"/>.</param>
/// <param name="inputSchemaDefinition">The schema definition overrides for <typeparamref name="TSrc"/></param>
/// <param name="outputSchemaDefinition">The schema definition overrides for <typeparamref name="TDst"/></param>
public StatefulFilterTransform(IHostEnvironment env, IDataView source, Func <TSrc, TDst, TState, bool> filterFunc,
Action <TState> initStateAction,
Action <BinaryWriter> saveAction, LambdaTransform.LoadDelegate loadFunc,
SchemaDefinition inputSchemaDefinition = null, SchemaDefinition outputSchemaDefinition = null)
: base(env, RegistrationName, saveAction, loadFunc)
{
Host.AssertValue(source, "source");
Host.AssertValue(filterFunc, "filterFunc");
Host.AssertValueOrNull(initStateAction);
Host.AssertValueOrNull(inputSchemaDefinition);
Host.AssertValueOrNull(outputSchemaDefinition);
_source = source;
_filterFunc = filterFunc;
_initStateAction = initStateAction;
_inputSchemaDefinition = inputSchemaDefinition;
_typedSource = TypedCursorable <TSrc> .Create(Host, Source, false, inputSchemaDefinition);
var outSchema = InternalSchemaDefinition.Create(typeof(TDst), outputSchemaDefinition);
_addedSchema = outSchema;
_bindings = new ColumnBindings(Schema.Create(Source.Schema), DataViewConstructionUtils.GetSchemaColumns(outSchema));
}
public TypedCursor(TypedCursorable <TRow> parent, IRowCursor input)
: base(parent, input, "Cursor")
{
_input = input;
}
public TypedRow(TypedCursorable <TRow> parent, IRow input)
: base(parent, input, "Row")
{
}
