Class AbstractTransformationRule<TIn1, TIn2, TOut>

Namespace

NMF.Transformations

Assembly

NMF.Transformations.dll

Defines a transformation rule with two input arguments that is abstract, i.e. it cannot create an output This means that there must exist transformation rules that are marked instantiating for this rule.

public abstract class AbstractTransformationRule<TIn1, TIn2, TOut> : TransformationRule<TIn1, TIn2, TOut> where TIn1 : class where TIn2 : class where TOut : class

Type Parameters

TIn1

The type of the first input argument for this transformation rule

TIn2

The type of the second input argument for this transformation rule

TOut

The type of output, that is generated in an instantiating rule

Inheritance

object

GeneralTransformationRule

GeneralTransformationRule<TIn1, TIn2>

TransformationRuleBase<TIn1, TIn2, TOut>

TransformationRule<TIn1, TIn2, TOut>

AbstractTransformationRule<TIn1, TIn2, TOut>

Inherited Members

TransformationRule<TIn1, TIn2, TOut>.NeedDependenciesForOutputCreation

TransformationRule<TIn1, TIn2, TOut>.CreateComputation(object[], IComputationContext)

TransformationRule<TIn1, TIn2, TOut>.CreateOutput(TIn1, TIn2, ITransformationContext)

TransformationRule<TIn1, TIn2, TOut>.Transform(TIn1, TIn2, TOut, ITransformationContext)

TransformationRuleBase<TIn1, TIn2, TOut>.MarkInstantiatingFor<TRequiredInput1, TRequiredInput2, TRequiredOutput>()

TransformationRuleBase<TIn1, TIn2, TOut>.MarkInstantiatingFor<TRequiredInput1, TRequiredInput2, TRequiredOutput>(Func<TIn1, TIn2, bool>)

TransformationRuleBase<TIn1, TIn2, TOut>.OutputType

TransformationRuleBase<TIn1, TIn2, TOut>.RequireByType<TRequiredInput1, TRequiredInput2, TRequiredOutput>(Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.RequireByType<TRequiredInput1, TRequiredInput2, TRequiredOutput>(Func<TIn1, TIn2, TRequiredInput1>, Func<TIn1, TIn2, TRequiredInput2>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.RequireByType<TRequiredInput, TRequiredOutput>(Func<TIn1, TIn2, TRequiredInput>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.Require<TRequiredInput1, TRequiredInput2, TRequiredOutput>(TransformationRuleBase<TRequiredInput1, TRequiredInput2, TRequiredOutput>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.Require<TRequiredInput1, TRequiredInput2, TRequiredOutput>(TransformationRuleBase<TRequiredInput1, TRequiredInput2, TRequiredOutput>, Func<TIn1, TIn2, TRequiredInput1>, Func<TIn1, TIn2, TRequiredInput2>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.Require<TRequiredInput, TRequiredOutput>(TransformationRuleBase<TRequiredInput, TRequiredOutput>, Func<TIn1, TIn2, TRequiredInput>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.RequireManyByType<TRequiredInput1, TRequiredInput2, TRequiredOutput>(Func<TIn1, TIn2, IEnumerable<Tuple<TRequiredInput1, TRequiredInput2>>>, Action<TOut, IEnumerable<TRequiredOutput>>)

TransformationRuleBase<TIn1, TIn2, TOut>.RequireManyByType<TRequiredInput, TRequiredOutput>(Func<TIn1, TIn2, IEnumerable<TRequiredInput>>, Action<TOut, IEnumerable<TRequiredOutput>>)

TransformationRuleBase<TIn1, TIn2, TOut>.RequireMany<TRequiredInput1, TRequiredInput2, TRequiredOutput>(TransformationRuleBase<TRequiredInput1, TRequiredInput2, TRequiredOutput>, Func<TIn1, TIn2, IEnumerable<Tuple<TRequiredInput1, TRequiredInput2>>>, Action<TOut, IEnumerable<TRequiredOutput>>)

TransformationRuleBase<TIn1, TIn2, TOut>.RequireMany<TRequiredInput, TRequiredOutput>(TransformationRuleBase<TRequiredInput, TRequiredOutput>, Func<TIn1, TIn2, IEnumerable<TRequiredInput>>, Action<TOut, IEnumerable<TRequiredOutput>>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallByType<TRequiredInput1, TRequiredInput2, TRequiredOutput>(Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallByType<TRequiredInput1, TRequiredInput2, TRequiredOutput>(Func<TIn1, TIn2, TRequiredInput1>, Func<TIn1, TIn2, TRequiredInput2>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallByType<TRequiredInput, TRequiredOutput>(Func<TIn1, TIn2, TRequiredInput>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.Call<TRequiredInput1, TRequiredInput2, TRequiredOutput>(TransformationRuleBase<TRequiredInput1, TRequiredInput2, TRequiredOutput>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.Call<TRequiredInput1, TRequiredInput2, TRequiredOutput>(TransformationRuleBase<TRequiredInput1, TRequiredInput2, TRequiredOutput>, Func<TIn1, TIn2, TRequiredInput1>, Func<TIn1, TIn2, TRequiredInput2>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.Call<TRequiredInput, TRequiredOutput>(TransformationRuleBase<TRequiredInput, TRequiredOutput>, Func<TIn1, TIn2, TRequiredInput>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallManyByType<TRequiredInput1, TRequiredInput2, TRequiredOutput>(Func<TIn1, TIn2, IEnumerable<Tuple<TRequiredInput1, TRequiredInput2>>>, Action<TOut, IEnumerable<TRequiredOutput>>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallManyByType<TRequiredInput, TRequiredOutput>(Func<TIn1, TIn2, IEnumerable<TRequiredInput>>, Action<TOut, IEnumerable<TRequiredOutput>>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallMany<TRequiredInput1, TRequiredInput2, TRequiredOutput>(TransformationRuleBase<TRequiredInput1, TRequiredInput2, TRequiredOutput>, Func<TIn1, TIn2, IEnumerable<Tuple<TRequiredInput1, TRequiredInput2>>>, Action<TOut, IEnumerable<TRequiredOutput>>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallMany<TRequiredInput, TRequiredOutput>(TransformationRuleBase<TRequiredInput, TRequiredOutput>, Func<TIn1, TIn2, IEnumerable<TRequiredInput>>, Action<TOut, IEnumerable<TRequiredOutput>>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallFor<TRequiredInput1, TRequiredInput2, TRequiredOutput>(Func<TRequiredInput1, TRequiredInput2, TIn1>, Func<TRequiredInput1, TRequiredInput2, TIn2>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallFor<TRequiredInput, TRequiredOutput>(Func<TRequiredInput, TIn1>, Func<TRequiredInput, TIn2>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallFor<TRequiredInput1, TRequiredInput2, TRequiredOutput>(Func<TRequiredInput1, TRequiredInput2, TIn1>, Func<TRequiredInput1, TRequiredInput2, TIn2>, Func<TRequiredInput1, TRequiredInput2, bool>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallFor<TRequiredInput, TRequiredOutput>(Func<TRequiredInput, TIn1>, Func<TRequiredInput, TIn2>, Func<TRequiredInput, bool>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallFor<TRequiredInput1, TRequiredInput2, TRequiredOutput>(TransformationRuleBase<TRequiredInput1, TRequiredInput2, TRequiredOutput>, Func<TRequiredInput1, TRequiredInput2, TIn1>, Func<TRequiredInput1, TRequiredInput2, TIn2>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallFor<TRequiredInput, TRequiredOutput>(TransformationRuleBase<TRequiredInput, TRequiredOutput>, Func<TRequiredInput, TIn1>, Func<TRequiredInput, TIn2>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallFor<TRequiredInput1, TRequiredInput2, TRequiredOutput>(TransformationRuleBase<TRequiredInput1, TRequiredInput2, TRequiredOutput>, Func<TRequiredInput1, TRequiredInput2, TIn1>, Func<TRequiredInput1, TRequiredInput2, TIn2>, Func<TRequiredInput1, TRequiredInput2, bool>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallFor<TRequiredInput, TRequiredOutput>(TransformationRuleBase<TRequiredInput, TRequiredOutput>, Func<TRequiredInput, TIn1>, Func<TRequiredInput, TIn2>, Func<TRequiredInput, bool>, Action<TOut, TRequiredOutput>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallForEach<TRequiredInput1, TRequiredInput2, TRequiredOutput>(Func<TRequiredInput1, TRequiredInput2, IEnumerable<Tuple<TIn1, TIn2>>>, Action<TRequiredOutput, IEnumerable<TOut>>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallForEach<TRequiredInput, TRequiredOutput>(Func<TRequiredInput, IEnumerable<Tuple<TIn1, TIn2>>>, Action<TRequiredOutput, IEnumerable<TOut>>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallForEach<TRequiredInput1, TRequiredInput2, TRequiredOutput>(Func<TRequiredInput1, TRequiredInput2, IEnumerable<Tuple<TIn1, TIn2>>>, Func<TRequiredInput1, TRequiredInput2, bool>, Action<TRequiredOutput, IEnumerable<TOut>>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallForEach<TRequiredInput, TRequiredOutput>(Func<TRequiredInput, IEnumerable<Tuple<TIn1, TIn2>>>, Func<TRequiredInput, bool>, Action<TRequiredOutput, IEnumerable<TOut>>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallForEach<TRequiredInput1, TRequiredInput2, TRequiredOutput>(TransformationRuleBase<TRequiredInput1, TRequiredInput2, TRequiredOutput>, Func<TRequiredInput1, TRequiredInput2, IEnumerable<Tuple<TIn1, TIn2>>>, Action<TRequiredOutput, IEnumerable<TOut>>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallForEach<TRequiredInput, TRequiredOutput>(TransformationRuleBase<TRequiredInput, TRequiredOutput>, Func<TRequiredInput, IEnumerable<Tuple<TIn1, TIn2>>>, Action<TRequiredOutput, IEnumerable<TOut>>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallForEach<TRequiredInput1, TRequiredInput2, TRequiredOutput>(TransformationRuleBase<TRequiredInput1, TRequiredInput2, TRequiredOutput>, Func<TRequiredInput1, TRequiredInput2, IEnumerable<Tuple<TIn1, TIn2>>>, Func<TRequiredInput1, TRequiredInput2, bool>, Action<TRequiredOutput, IEnumerable<TOut>>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallForEach<TRequiredInput, TRequiredOutput>(TransformationRuleBase<TRequiredInput, TRequiredOutput>, Func<TRequiredInput, IEnumerable<Tuple<TIn1, TIn2>>>, Func<TRequiredInput, bool>, Action<TRequiredOutput, IEnumerable<TOut>>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallOutputSensitive<TRequiredInput1, TRequiredInput2>(GeneralTransformationRule<TRequiredInput1, TRequiredInput2>, Func<TIn1, TIn2, TOut, TRequiredInput1>, Func<TIn1, TIn2, TOut, TRequiredInput2>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallOutputSensitive<TRequiredInput1, TRequiredInput2>(GeneralTransformationRule<TRequiredInput1, TRequiredInput2>, Func<TIn1, TIn2, TOut, TRequiredInput1>, Func<TIn1, TIn2, TOut, TRequiredInput2>, Func<TIn1, TIn2, TOut, bool>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallOutputSensitive<TRequiredInput>(GeneralTransformationRule<TRequiredInput>, Func<TIn1, TIn2, TOut, TRequiredInput>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallOutputSensitive<TRequiredInput>(GeneralTransformationRule<TRequiredInput>, Func<TIn1, TIn2, TOut, TRequiredInput>, Func<TIn1, TIn2, TOut, bool>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallManyOutputSensitive<TRequiredInput1, TRequiredInput2>(GeneralTransformationRule<TRequiredInput1, TRequiredInput2>, Func<TIn1, TIn2, TOut, IEnumerable<Tuple<TRequiredInput1, TRequiredInput2>>>)

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

TransformationRuleBase<TIn1, TIn2, TOut>.CallManyOutputSensitive<TRequiredInput>(GeneralTransformationRule<TRequiredInput>, Func<TIn1, TIn2, TOut, IEnumerable<TRequiredInput>>)

TransformationRuleBase<TIn1, TIn2, TOut>.CallManyOutputSensitive<TRequiredInput>(GeneralTransformationRule<TRequiredInput>, Func<TIn1, TIn2, TOut, IEnumerable<TRequiredInput>>, Func<TIn1, TIn2, TOut, bool>)

TransformationRuleBase<TIn1, TIn2, TOut>.TraceOutput<TKey>(Func<TIn1, TIn2, TOut, TKey>)

TransformationRuleBase<TIn1, TIn2, TOut>.TraceOutput<TKey>(TraceEntryGroup<TKey, TOut>, Func<TIn1, TIn2, TOut, TKey>)

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.CreateComputation(object[], IComputationContext)

GeneralTransformationRule.NeedDependenciesForOutputCreation

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()

Extension Methods

IncrementalExtensions.ToComputationSource<TInput1, TInput2, TOutput>(TransformationRuleBase<TInput1, TInput2, TOutput>)

IncrementalExtensions.ToComputationSource<TInput1, TInput2, TOutput>(TransformationRuleBase<TInput1, TInput2, TOutput>, ITransformationContext)

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

IncrementalExtensions.ToComputationSource<TInput1, TInput2, TOutput>(TransformationRuleBase<TInput1, TInput2, TOutput>, ITransformationContext, bool, Func<TransformationComputationWrapper<TInput1, TInput2, TOutput>, bool>)

IncrementalExtensions.ToComputationSource<TInput1, TInput2, TOutput>(TransformationRuleBase<TInput1, TInput2, TOutput>, ITransformationContext, Func<TransformationComputationWrapper<TInput1, TInput2, TOutput>, bool>)

IncrementalExtensions.ToComputationSource<TInput1, TInput2, TOutput>(TransformationRuleBase<TInput1, TInput2, TOutput>, bool)

IncrementalExtensions.ToComputationSource<TInput1, TInput2, TOutput>(TransformationRuleBase<TInput1, TInput2, TOutput>, bool, Func<TransformationComputationWrapper<TInput1, TInput2, TOutput>, bool>)

IncrementalExtensions.ToComputationSource<TInput1, TInput2, TOutput>(TransformationRuleBase<TInput1, TInput2, TOutput>, Func<TransformationComputationWrapper<TInput1, TInput2, TOutput>, bool>)

Methods

CreateOutput(TIn1, TIn2, ITransformationContext)

Creates the output of this transformation rule

public override TOut CreateOutput(TIn1 input1, TIn2 input2, ITransformationContext context)

Parameters

input1 TIn1

The first input argument for this computation

input2 TIn2

The second input argument for this computation

context ITransformationContext

The context in which the output is required

Returns

TOut

The output for this transformation

Remarks

Creation of transformation rule outputs is not supported for abstract transformation rules and thus, calling this method will result in an InvalidOperationException