public static TOut ResolveIn <TOut>(this ITransformationTrace trace, TransformationRuleBase <TOut> rule, object[] input)
where TOut : class
{
if (trace == null)
{
throw new ArgumentNullException("trace");
}
var comp = trace.TraceIn(rule, input).FirstOrDefault();
return(comp != null ? comp.Output as TOut : null);
}
/// <summary>
/// Creates a new transformation computation for the given input arguments
/// </summary>
/// <param name="transformationRule">The transformation rule for this computation</param>
/// <param name="context">The context of this computation</param>
/// <param name="input">The input for this computation</param>
protected TransformationComputation(TransformationRuleBase <TIn, TOut> transformationRule, IComputationContext context, TIn input)
: base(transformationRule, context, input)
{
}
public static IEnumerable <TOut> TransformMany <TIn, TOut>(IEnumerable <TIn> inputs, ITransformationEngineContext context, TransformationRuleBase <TIn, TOut> startRule)
where TIn : class
where TOut : class
{
if (context == null)
{
throw new ArgumentNullException("context");
}
var transformation = context.Transformation;
if (!transformation.IsInitialized)
{
transformation.Initialize();
}
if (startRule == null)
{
startRule = context.Transformation.GetRuleForTypeSignature(new Type[] { typeof(TIn) }, typeof(TOut)) as TransformationRuleBase <TIn, TOut>;
}
else
{
if (startRule.Transformation != context.Transformation)
{
ThrowRuleNotPartOfTransformation();
}
}
return(TransformationRunner.TransformMany(inputs.Select(item => new object[] { item }), null, startRule, context).Select(c => c.Output).OfType <TOut>());
}
public static TOut Transform <TIn, TOut>(TIn input, ITransformationEngineContext context, TransformationRuleBase <TIn, TOut> startRule)
where TIn : class
where TOut : class
{
if (context == null)
{
throw new ArgumentNullException("context");
}
var transformation = context.Transformation;
if (!transformation.IsInitialized)
{
transformation.Initialize();
}
if (startRule == null)
{
startRule = context.Transformation.GetRuleForTypeSignature(new Type[] { typeof(TIn) }, typeof(TOut)) as TransformationRuleBase <TIn, TOut>;
}
else
{
if (startRule.Transformation != context.Transformation)
{
ThrowRuleNotPartOfTransformation();
}
}
return(TransformationRunner.Transform(new object[] { input }, null, startRule, context).Output as TOut);
}
/// <summary>
/// Creates a new trace-only computation
/// </summary>
/// <param name="rule">The transformation rule used as trace group</param>
/// <param name="input">The trace key for this transformation rule</param>
/// <param name="output">The output for this trace entry</param>
public TraceEntry(TransformationRuleBase <TInput, TOut> rule, TInput input, TOut output)
{
this.input = input;
this.output = output;
this.transformationRule = rule;
}
/// <summary>
/// Trace the output of the computation that transformed any input that matches the filter with the given transformation type
/// </summary>
/// <param name="trace">The trace component that is used as basis</param>
/// <typeparam name="TIn">The input type that is looked for</typeparam>
/// <param name="rule">The transformation rule the object was transformed with</param>
/// <typeparam name="TOut">The output that is returned by the transformation rule</typeparam>
/// <param name="list">A list of allowed input arguments</param>
/// <returns>All outputs of computations with suitable input arguments or null, if there are none</returns>
public static IEnumerable <TOut> ResolveManyIn <TIn, TOut>(this ITransformationTrace trace, TransformationRuleBase <TIn, TOut> rule, params TIn[] list)
where TIn : class
where TOut : class
{
return(ResolveManyIn <TIn, TOut>(trace, rule, list as IEnumerable <TIn>));
}
public static IEnumerable <TOut> ResolveInWhere <TIn1, TIn2, TOut>(this ITransformationTrace trace, TransformationRuleBase <TIn1, TIn2, TOut> rule, Func <TIn1, TIn2, bool> filter)
where TIn1 : class
where TIn2 : class
where TOut : class
{
if (trace == null)
{
throw new ArgumentNullException("trace");
}
return(from ITraceEntry c in trace.TraceAllIn(rule)
where (filter == null || filter(c.GetInput(0) as TIn1, c.GetInput(1) as TIn2))
select c.Output as TOut);
}
public static IEnumerable <TOut> FindAllIn <TIn1, TIn2, TOut>(this ITransformationTrace trace, TransformationRuleBase <TIn1, TIn2, TOut> rule)
where TOut : class
where TIn1 : class
where TIn2 : class
{
if (trace == null)
{
throw new ArgumentNullException("trace");
}
return(trace.TraceAllIn(rule).Select(c => c.Output as TOut));
}
public static IEnumerable <TOut> FindInWhere <TOut>(this ITransformationTrace trace, TransformationRuleBase <TOut> rule, Predicate <TOut> filter)
where TOut : class
{
if (trace == null)
{
throw new ArgumentNullException("trace");
}
return(trace.TraceAllIn(rule).Select(c => c.Output as TOut).Where(o => filter == null || filter(o)));
}
public static IEnumerable <TOut> ResolveInWhere <TOut>(this ITransformationTrace trace, TransformationRuleBase <TOut> rule, Predicate <object[]> filter)
where TOut : class
{
if (trace == null)
{
throw new ArgumentNullException("trace");
}
return(from ITraceEntry c in trace.TraceAllIn(rule)
where filter == null || filter(c.CreateInputArray())
select c.Output as TOut);
}
public static IEnumerable <TOut> ResolveManyIn <TIn, TOut>(this ITransformationTrace trace, TransformationRuleBase <TIn, TOut> rule, IEnumerable <TIn> list)
where TIn : class
where TOut : class
{
if (trace == null)
{
throw new ArgumentNullException("trace");
}
if (list == null)
{
return(Enumerable.Empty <TOut>());
}
return(from ITraceEntry c in trace.TraceManyIn(rule, list.Select(input => new object[] { input }))
select c.Output as TOut);
}
public static IEnumerable <TOut> ResolveManyIn <TIn, TOut>(this ITransformationTrace trace, TransformationRuleBase <TIn, TOut> rule, TIn input)
where TIn : class
where TOut : class
{
if (trace == null)
{
throw new ArgumentNullException("trace");
}
return(from ITraceEntry c in trace.TraceIn(rule, input)
select c.Output as TOut);
}