Class TransformationRule<TIn1, TIn2, TOut>

Namespace

NMF.Transformations

Assembly

NMF.Transformations.dll

Defines a simple transformation rule of a transformation that has one input argument and an output

public class TransformationRule<TIn1, TIn2, TOut> : TransformationRuleBase<TIn1, TIn2, TOut> where TIn1 : class where TIn2 : class where TOut : class

Type Parameters

TIn1

The type of the first input argument

TIn2

The type of the second input argument

TOut

The type of the output

Inheritance

object

GeneralTransformationRule

GeneralTransformationRule<TIn1, TIn2>

TransformationRuleBase<TIn1, TIn2, TOut>

TransformationRule<TIn1, TIn2, TOut>

Derived

Meta2ClassesTransformation.RefinedAttributeCollectionClassGenerator

Meta2ClassesTransformation.RefinedAttributeGenerator

Meta2ClassesTransformation.RefinedReferenceCollectionClassGenerator

Meta2ClassesTransformation.RefinedReferenceGenerator

AbstractTransformationRule<TIn1, TIn2, TOut>

Inherited Members

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

Remarks

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

Constructors

TransformationRule()

Creates a new transformation rule

public TransformationRule()

Properties

NeedDependenciesForOutputCreation

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

public override bool NeedDependenciesForOutputCreation { get; }

Property Value

bool

Methods

CreateComputation(object[], IComputationContext)

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

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

Parameters

input object[]

The input arguments for this computation

context IComputationContext

The context for this computation

Returns

Computation

A computation object

CreateOutput(TIn1, TIn2, ITransformationContext)

Creates the output of this transformation rule

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

Parameters

input1 TIn1

The first input of the transformation rule

input2 TIn2

The second input of the transformation rule

context ITransformationContext

The context (and trace!) object

Returns

TOut

The output for this transformation under this input

Remarks

At this point, not all of the computations have created their output and thus, the trace is not complete. Use the OutputDelayLevel-feature to have the trace contain all elements created in earlier levels

Transform(TIn1, TIn2, TOut, ITransformationContext)

Initializes the transformation output

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

Parameters

input1 TIn1

The first input of the transformation rule

input2 TIn2

The second input of the transformation rule

output TOut

The output of the transformation rule generated earlier

context ITransformationContext

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