Class InPlaceTransformationRule<TIn1, TIn2>

Defines a simple transformation rule of a transformation that has two inputs argument and no output

Inheritance

object

GeneralTransformationRule

GeneralTransformationRule<TIn1, TIn2>

InPlaceTransformationRuleBase<TIn1, TIn2>

InPlaceTransformationRule<TIn1, TIn2>

Inherited Members

InPlaceTransformationRuleBase<TIn1, TIn2>.OutputType

GeneralTransformationRule<TIn1, TIn2>.MarkInstantiatingFor(GeneralTransformationRule, Func<TIn1, TIn2, bool>)

GeneralTransformationRule<TIn1, TIn2>.Rule<TRule>()

GeneralTransformationRule<TIn1, TIn2>.InputType

GeneralTransformationRule<TIn1, TIn2>.WithPattern(ITransformationRulePattern<TIn1, TIn2>)

GeneralTransformationRule<TIn1, TIn2>.WithPattern(Func<ITransformationContext, INotifyEnumerable<Tuple<TIn1, TIn2>>>)

GeneralTransformationRule<TIn1, TIn2>.WithPattern(Func<ITransformationContext, IEnumerable<Tuple<TIn1, TIn2>>>)

GeneralTransformationRule<TIn1, TIn2>.RequireByType<TRequiredInput1, TRequiredInput2>()

GeneralTransformationRule<TIn1, TIn2>.RequireByType<TRequiredInput1, TRequiredInput2>(Func<TIn1, TIn2, TRequiredInput1>, Func<TIn1, TIn2, TRequiredInput2>)

GeneralTransformationRule<TIn1, TIn2>.RequireByType<TRequiredInput>(Func<TIn1, TIn2, TRequiredInput>)

GeneralTransformationRule<TIn1, TIn2>.Require(GeneralTransformationRule<TIn1, TIn2>, Func<TIn1, TIn2, bool>)

GeneralTransformationRule<TIn1, TIn2>.Require<TRequiredInput1, TRequiredInput2>(GeneralTransformationRule<TRequiredInput1, TRequiredInput2>, Func<TIn1, TIn2, TRequiredInput1>, Func<TIn1, TIn2, TRequiredInput2>)

GeneralTransformationRule<TIn1, TIn2>.Require<TRequiredInput>(GeneralTransformationRule<TRequiredInput>, Func<TIn1, TIn2, TRequiredInput>)

GeneralTransformationRule<TIn1, TIn2>.Require(GeneralTransformationRule, Func<TIn1, TIn2, object[]>)

GeneralTransformationRule<TIn1, TIn2>.RequireManyByType<TRequiredInput1, TRequiredInput2>(Func<TIn1, TIn2, IEnumerable<Tuple<TRequiredInput1, TRequiredInput2>>>)

GeneralTransformationRule<TIn1, TIn2>.RequireManyByType<TRequiredInput>(Func<TIn1, TIn2, IEnumerable<TRequiredInput>>)

GeneralTransformationRule<TIn1, TIn2>.RequireMany<TRequiredInput1, TRequiredInput2>(GeneralTransformationRule<TRequiredInput1, TRequiredInput2>, Func<TIn1, TIn2, IEnumerable<Tuple<TRequiredInput1, TRequiredInput2>>>)

GeneralTransformationRule<TIn1, TIn2>.RequireMany<TRequiredInput>(GeneralTransformationRule<TRequiredInput>, Func<TIn1, TIn2, IEnumerable<TRequiredInput>>)

GeneralTransformationRule<TIn1, TIn2>.CallByType<TRequiredInput1, TRequiredInput2>()

GeneralTransformationRule<TIn1, TIn2>.Call<TRequiredInput1, TRequiredInput2>(GeneralTransformationRule<TRequiredInput1, TRequiredInput2>)

GeneralTransformationRule<TIn1, TIn2>.CallByType<TRequiredInput1, TRequiredInput2>(Func<TIn1, TIn2, TRequiredInput1>, Func<TIn1, TIn2, TRequiredInput2>)

GeneralTransformationRule<TIn1, TIn2>.CallByType<TRequiredInput>(Func<TIn1, TIn2, TRequiredInput>)

GeneralTransformationRule<TIn1, TIn2>.Call<TRequiredInput1, TRequiredInput2>(GeneralTransformationRule<TRequiredInput1, TRequiredInput2>, Func<TIn1, TIn2, TRequiredInput1>, Func<TIn1, TIn2, TRequiredInput2>)

GeneralTransformationRule<TIn1, TIn2>.Call(GeneralTransformationRule<TIn1, TIn2>, Func<TIn1, TIn2, bool>)

GeneralTransformationRule<TIn1, TIn2>.Call<TRequiredInput>(GeneralTransformationRule<TRequiredInput>, Func<TIn1, TIn2, TRequiredInput>)

GeneralTransformationRule<TIn1, TIn2>.CallManyByType<TRequiredInput1, TRequiredInput2>(Func<TIn1, TIn2, IEnumerable<Tuple<TRequiredInput1, TRequiredInput2>>>)

GeneralTransformationRule<TIn1, TIn2>.CallManyByType<TRequiredInput>(Func<TIn1, TIn2, IEnumerable<TRequiredInput>>)

GeneralTransformationRule<TIn1, TIn2>.CallMany<TRequiredInput1, TRequiredInput2>(GeneralTransformationRule<TRequiredInput1, TRequiredInput2>, Func<TIn1, TIn2, IEnumerable<Tuple<TRequiredInput1, TRequiredInput2>>>)

GeneralTransformationRule<TIn1, TIn2>.CallMany<TRequiredInput>(GeneralTransformationRule<TRequiredInput>, Func<TIn1, TIn2, IEnumerable<TRequiredInput>>)

GeneralTransformationRule<TIn1, TIn2>.CallFor<TRequiredInput1, TRequiredInput2>(Func<TRequiredInput1, TRequiredInput2, TIn1>, Func<TRequiredInput1, TRequiredInput2, TIn2>)

GeneralTransformationRule<TIn1, TIn2>.CallFor<TRequiredInput1, TRequiredInput2>(Func<TRequiredInput1, TRequiredInput2, TIn1>, Func<TRequiredInput1, TRequiredInput2, TIn2>, Func<TRequiredInput1, TRequiredInput2, bool>)

GeneralTransformationRule<TIn1, TIn2>.CallFor<TRequiredInput1, TRequiredInput2>(GeneralTransformationRule<TRequiredInput1, TRequiredInput2>, Func<TRequiredInput1, TRequiredInput2, TIn1>, Func<TRequiredInput1, TRequiredInput2, TIn2>)

GeneralTransformationRule<TIn1, TIn2>.CallFor<TRequiredInput1, TRequiredInput2>(GeneralTransformationRule<TRequiredInput1, TRequiredInput2>, Func<TRequiredInput1, TRequiredInput2, TIn1>, Func<TRequiredInput1, TRequiredInput2, TIn2>, Func<TRequiredInput1, TRequiredInput2, bool>)

GeneralTransformationRule<TIn1, TIn2>.CallFor<TRequiredInput>(Func<TRequiredInput, TIn1>, Func<TRequiredInput, TIn2>)

GeneralTransformationRule<TIn1, TIn2>.CallFor<TRequiredInput>(Func<TRequiredInput, TIn1>, Func<TRequiredInput, TIn2>, Func<TRequiredInput, bool>)

GeneralTransformationRule<TIn1, TIn2>.CallFor<TRequiredInput>(GeneralTransformationRule<TRequiredInput>, Func<TRequiredInput, TIn1>, Func<TRequiredInput, TIn2>)

GeneralTransformationRule<TIn1, TIn2>.CallFor<TRequiredInput>(GeneralTransformationRule<TRequiredInput>, Func<TRequiredInput, TIn1>, Func<TRequiredInput, TIn2>, Func<TRequiredInput, bool>)

GeneralTransformationRule<TIn1, TIn2>.CallForOutputSensitive<TRequiredInput1, TRequiredInput2, TRequiredOutput>(Func<TRequiredInput1, TRequiredInput2, TRequiredOutput, TIn1>, Func<TRequiredInput1, TRequiredInput2, TRequiredOutput, TIn2>)

GeneralTransformationRule<TIn1, TIn2>.CallForOutputSensitive<TRequiredInput1, TRequiredInput2, TRequiredOutput>(Func<TRequiredInput1, TRequiredInput2, TRequiredOutput, TIn1>, Func<TRequiredInput1, TRequiredInput2, TRequiredOutput, TIn2>, Func<TRequiredInput1, TRequiredInput2, TRequiredOutput, bool>)

GeneralTransformationRule<TIn1, TIn2>.CallForOutputSensitive<TRequiredInput1, TRequiredInput2, TRequiredOutput>(TransformationRuleBase<TRequiredInput1, TRequiredInput2, TRequiredOutput>, Func<TRequiredInput1, TRequiredInput2, TRequiredOutput, TIn1>, Func<TRequiredInput1, TRequiredInput2, TRequiredOutput, TIn2>)

GeneralTransformationRule<TIn1, TIn2>.CallForOutputSensitive<TRequiredInput1, TRequiredInput2, TRequiredOutput>(TransformationRuleBase<TRequiredInput1, TRequiredInput2, TRequiredOutput>, Func<TRequiredInput1, TRequiredInput2, TRequiredOutput, TIn1>, Func<TRequiredInput1, TRequiredInput2, TRequiredOutput, TIn2>, Func<TRequiredInput1, TRequiredInput2, TRequiredOutput, bool>)

GeneralTransformationRule<TIn1, TIn2>.CallForOutputSensitive<TRequiredInput, TRequiredOutput>(Func<TRequiredInput, TRequiredOutput, TIn1>, Func<TRequiredInput, TRequiredOutput, TIn2>)

GeneralTransformationRule<TIn1, TIn2>.CallForOutputSensitive<TRequiredInput, TRequiredOutput>(Func<TRequiredInput, TRequiredOutput, TIn1>, Func<TRequiredInput, TRequiredOutput, TIn2>, Func<TRequiredInput, TRequiredOutput, bool>)

GeneralTransformationRule<TIn1, TIn2>.CallForOutputSensitive<TRequiredInput, TRequiredOutput>(TransformationRuleBase<TRequiredInput, TRequiredOutput>, Func<TRequiredInput, TRequiredOutput, TIn1>, Func<TRequiredInput, TRequiredOutput, TIn2>)

GeneralTransformationRule<TIn1, TIn2>.CallForOutputSensitive<TRequiredInput, TRequiredOutput>(TransformationRuleBase<TRequiredInput, TRequiredOutput>, Func<TRequiredInput, TRequiredOutput, TIn1>, Func<TRequiredInput, TRequiredOutput, TIn2>, Func<TRequiredInput, TRequiredOutput, bool>)

GeneralTransformationRule<TIn1, TIn2>.CallForEach<TRequiredInput1, TRequiredInput2>(Func<TRequiredInput1, TRequiredInput2, IEnumerable<Tuple<TIn1, TIn2>>>)

GeneralTransformationRule<TIn1, TIn2>.CallForEach<TRequiredInput1, TRequiredInput2>(Func<TRequiredInput1, TRequiredInput2, IEnumerable<Tuple<TIn1, TIn2>>>, Func<TRequiredInput1, TRequiredInput2, bool>)

GeneralTransformationRule<TIn1, TIn2>.CallForEach<TRequiredInput1, TRequiredInput2>(GeneralTransformationRule<TRequiredInput1, TRequiredInput2>, Func<TRequiredInput1, TRequiredInput2, IEnumerable<Tuple<TIn1, TIn2>>>)

GeneralTransformationRule<TIn1, TIn2>.CallForEach<TRequiredInput1, TRequiredInput2>(GeneralTransformationRule<TRequiredInput1, TRequiredInput2>, Func<TRequiredInput1, TRequiredInput2, IEnumerable<Tuple<TIn1, TIn2>>>, Func<TRequiredInput1, TRequiredInput2, bool>)

GeneralTransformationRule<TIn1, TIn2>.CallForEach<TRequiredInput>(Func<TRequiredInput, IEnumerable<Tuple<TIn1, TIn2>>>)

GeneralTransformationRule<TIn1, TIn2>.CallForEach<TRequiredInput>(Func<TRequiredInput, IEnumerable<Tuple<TIn1, TIn2>>>, Func<TRequiredInput, bool>)

GeneralTransformationRule<TIn1, TIn2>.CallForEach<TRequiredInput>(GeneralTransformationRule<TRequiredInput>, Func<TRequiredInput, IEnumerable<Tuple<TIn1, TIn2>>>)

GeneralTransformationRule<TIn1, TIn2>.CallForEach<TRequiredInput>(GeneralTransformationRule<TRequiredInput>, Func<TRequiredInput, IEnumerable<Tuple<TIn1, TIn2>>>, Func<TRequiredInput, bool>)

GeneralTransformationRule<TIn1, TIn2>.CallForEachOutputSensitive<TRequiredInput1, TRequiredInput2, TRequiredOutput>(Func<TRequiredInput1, TRequiredInput2, TRequiredOutput, IEnumerable<Tuple<TIn1, TIn2>>>)

GeneralTransformationRule<TIn1, TIn2>.CallForEachOutputSensitive<TRequiredInput1, TRequiredInput2, TRequiredOutput>(Func<TRequiredInput1, TRequiredInput2, TRequiredOutput, IEnumerable<Tuple<TIn1, TIn2>>>, Func<TRequiredInput1, TRequiredInput2, TRequiredOutput, bool>)

GeneralTransformationRule<TIn1, TIn2>.CallForEachOutputSensitive<TRequiredInput1, TRequiredInput2, TRequiredOutput>(TransformationRuleBase<TRequiredInput1, TRequiredInput2, TRequiredOutput>, Func<TRequiredInput1, TRequiredInput2, TRequiredOutput, IEnumerable<Tuple<TIn1, TIn2>>>)

GeneralTransformationRule<TIn1, TIn2>.CallForEachOutputSensitive<TRequiredInput1, TRequiredInput2, TRequiredOutput>(TransformationRuleBase<TRequiredInput1, TRequiredInput2, TRequiredOutput>, Func<TRequiredInput1, TRequiredInput2, TRequiredOutput, IEnumerable<Tuple<TIn1, TIn2>>>, Func<TRequiredInput1, TRequiredInput2, TRequiredOutput, bool>)

GeneralTransformationRule<TIn1, TIn2>.CallForEachOutputSensitive<TRequiredInput, TRequiredOutput>(Func<TRequiredInput, TRequiredOutput, IEnumerable<Tuple<TIn1, TIn2>>>)

GeneralTransformationRule<TIn1, TIn2>.CallForEachOutputSensitive<TRequiredInput, TRequiredOutput>(Func<TRequiredInput, TRequiredOutput, IEnumerable<Tuple<TIn1, TIn2>>>, Func<TRequiredInput, TRequiredOutput, bool>)

GeneralTransformationRule<TIn1, TIn2>.CallForEachOutputSensitive<TRequiredInput, TRequiredOutput>(TransformationRuleBase<TRequiredInput, TRequiredOutput>, Func<TRequiredInput, TRequiredOutput, IEnumerable<Tuple<TIn1, TIn2>>>)

GeneralTransformationRule<TIn1, TIn2>.CallForEachOutputSensitive<TRequiredInput, TRequiredOutput>(TransformationRuleBase<TRequiredInput, TRequiredOutput>, Func<TRequiredInput, TRequiredOutput, IEnumerable<Tuple<TIn1, TIn2>>>, Func<TRequiredInput, TRequiredOutput, bool>)

GeneralTransformationRule<TIn1, TIn2>.CallFor(GeneralTransformationRule, Func<Computation, Tuple<TIn1, TIn2>>, bool)

GeneralTransformationRule<TIn1, TIn2>.CallFor(GeneralTransformationRule, Func<Computation, Tuple<TIn1, TIn2>>, Predicate<Computation>, bool)

GeneralTransformationRule<TIn1, TIn2>.CallForEach(GeneralTransformationRule, Func<Computation, IEnumerable<Tuple<TIn1, TIn2>>>, bool)

GeneralTransformationRule<TIn1, TIn2>.CallForEach(GeneralTransformationRule, Func<Computation, IEnumerable<Tuple<TIn1, TIn2>>>, Predicate<Computation>, bool)

GeneralTransformationRule<TIn1, TIn2>.RequireMany(GeneralTransformationRule, Func<TIn1, TIn2, IEnumerable<object[]>>)

GeneralTransformationRule<TIn1, TIn2>.Call(GeneralTransformationRule, Func<TIn1, TIn2, object[]>)

GeneralTransformationRule<TIn1, TIn2>.CallMany(GeneralTransformationRule, Func<TIn1, TIn2, IEnumerable<object[]>>)

GeneralTransformationRule<TIn1, TIn2>.ToString()

GeneralTransformationRule.RegisterDependencies()

GeneralTransformationRule.InputType

GeneralTransformationRule.OutputType

GeneralTransformationRule.Transformation

GeneralTransformationRule.Dependencies

GeneralTransformationRule.OutputDelayLevel

GeneralTransformationRule.TransformationDelayLevel

GeneralTransformationRule.IsUnique

GeneralTransformationRule.BaseRule

GeneralTransformationRule.IsInstantiating(Computation)

GeneralTransformationRule.HasCompliantInput(Computation)

GeneralTransformationRule.Require(GeneralTransformationRule)

GeneralTransformationRule.Call(GeneralTransformationRule)

GeneralTransformationRule.MarkInstantiatingFor(GeneralTransformationRule)

GeneralTransformationRule.MarkInstantiatingFor(GeneralTransformationRule, Predicate<Computation>)

object.Equals(object)

object.Equals(object, object)

object.GetHashCode()

object.GetType()

object.MemberwiseClone()

object.ReferenceEquals(object, object)

object.ToString()

Namespace: NMF.Transformations

Assembly: NMF.Transformations.dll

Syntax

public abstract class InPlaceTransformationRule<TIn1, TIn2> : InPlaceTransformationRuleBase<TIn1, TIn2> where TIn1 : class where TIn2 : class

Type Parameters

Name	Description
TIn1	The type of the first input argument
TIn2	The type of the second input argument

Remarks

Simple means that the transformation rule does not require a custom computation class

Constructors

InPlaceTransformationRule()

Creates a new transformation rule

Declaration

public InPlaceTransformationRule()

Properties

NeedDependenciesForOutputCreation

Gets a value indicating whether the output for all dependencies must have been created before this rule creates the output

Declaration

public override bool NeedDependenciesForOutputCreation { get; }

Property Value

Type	Description
bool

Overrides

GeneralTransformationRule.NeedDependenciesForOutputCreation

Methods

CreateComputation(object[], IComputationContext)

Creates a new Computation instance for this transformation rule or the given input

Declaration

public override Computation CreateComputation(object[] input, IComputationContext context)

Parameters

Type	Name	Description
object[]	input	The input arguments for this computation
IComputationContext	context	The context for this computation

Returns

Type	Description
Computation	A computation object

Overrides

GeneralTransformationRule.CreateComputation(object[], IComputationContext)

Init(TIn1, TIn2, ITransformationContext)

Initializes the transformation. This is done before any other transformation rule hits Transform

Declaration

public virtual void Init(TIn1 input1, TIn2 input2, ITransformationContext context)

Parameters

Type	Name	Description
TIn1	input1	The first input for this transformation rule
TIn2	input2	The second input for this transformation rule
ITransformationContext	context	The current transformation context

Transform(TIn1, TIn2, ITransformationContext)

Initializes the transformation output

Declaration

public virtual void Transform(TIn1 input1, TIn2 input2, ITransformationContext context)

Parameters

Type	Name	Description
TIn1	input1	The first input of the transformation rule
TIn2	input2	The second input of the transformation rule
ITransformationContext	context	The context (and trace!) object

Remarks

At this point, all the transformation outputs are created (also the delayed ones), thus, the trace is fully reliable

Extension Methods

IncrementalExtensions.ToComputationSource<TInput1, TInput2>(InPlaceTransformationRuleBase<TInput1, TInput2>)

IncrementalExtensions.ToComputationSource<TInput1, TInput2>(InPlaceTransformationRuleBase<TInput1, TInput2>, ITransformationContext)

IncrementalExtensions.ToComputationSource<TInput1, TInput2>(InPlaceTransformationRuleBase<TInput1, TInput2>, ITransformationContext, bool)

IncrementalExtensions.ToComputationSource<TInput1, TInput2>(InPlaceTransformationRuleBase<TInput1, TInput2>, ITransformationContext, bool, Func<InPlaceComputationWrapper<TInput1, TInput2>, bool>)

IncrementalExtensions.ToComputationSource<TInput1, TInput2>(InPlaceTransformationRuleBase<TInput1, TInput2>, ITransformationContext, Func<InPlaceComputationWrapper<TInput1, TInput2>, bool>)

IncrementalExtensions.ToComputationSource<TInput1, TInput2>(InPlaceTransformationRuleBase<TInput1, TInput2>, bool)

IncrementalExtensions.ToComputationSource<TInput1, TInput2>(InPlaceTransformationRuleBase<TInput1, TInput2>, bool, Func<InPlaceComputationWrapper<TInput1, TInput2>, bool>)

IncrementalExtensions.ToComputationSource<TInput1, TInput2>(InPlaceTransformationRuleBase<TInput1, TInput2>, Func<InPlaceComputationWrapper<TInput1, TInput2>, bool>)