/// <summary>
/// On for clauses that configure tokens with three inputs, performs a strongly typed, arbitrary transformation that makes use of all inputs.
/// </summary>
/// <typeparam name = "TIn1">The type of the first input.</typeparam>
/// <typeparam name = "TIn2">The type of the seconbd input</typeparam>
/// <typeparam name = "TIn3">The type of the third input</typeparam>
/// <typeparam name = "TOut">The type of the output.</typeparam>
/// <param name="config">The for clause to which the step is added.</param>
/// <param name = "transform">The transformation.</param>
/// <returns></returns>
public static IForClause <TOut> Do3 <TIn1, TIn2, TIn3, TOut>
(this IForClause <IMultiInput> config, Func <TIn1, TIn2, TIn3, TOut> transform)
{
Func <IMultiInput, TOut> func = x => transform(x.Get <TIn1>(0), x.Get <TIn2>(1), x.Get <TIn3>(2));
return(config.Do(func));
}
/// <summary>
/// Performs a strongly typed, arbitrary transformation.
/// </summary>
/// <typeparam name="TIn">The type of the input.</typeparam>
/// <typeparam name="TOut">The type of the output.</typeparam>
/// <param name="config">The for clause to which the step is added.</param>
/// <param name="transform">The transformation to perform.</param>
/// <returns></returns>
public static IForClause <TOut> Do <TIn, TOut>
(this IForClause <TIn> config, Func <TIn, TOut> transform)
{
return(config.Attach(ProcessingStep.Do(transform)));
}
/// <summary>
/// Casts an arbitrary value to a sequence of type <code>Object</code>.
/// </summary>
/// <param name="config">The for clause to which the step is added.</param>
/// <returns></returns>
public static IForClause <IEnumerable <object> > AsSeq(this IForClause config)
{
return(config.Attach(ProcessingStep.As <IEnumerable <object> >()));
}
/// <summary>
/// Casts an arbitrary sequence to a specific sequence using the LINQ <code>OfType()</code> method.
/// </summary>
/// <typeparam name="T">The type of the target sequence.</typeparam>
/// <param name="config">The for clause to which the step is added.</param>
/// <returns></returns>
public static IForClause <IEnumerable <T> > SeqOfType <T>(this IForClause <IEnumerable> config)
{
return(config.Attach(ProcessingStep.SeqOfType <T>()));
}
/// <summary>
/// Joins a series of strings using one delimeter, and the last item with a different delimeter, they way one might join a sequence of words.
/// </summary>
/// <param name="config">The config.</param>
/// <param name="delimeter">The delimeter.</param>
/// <param name="lastDelimeter">The last delimeter.</param>
/// <returns></returns>
public static IForClause <string> WordJoin(this IForClause <IEnumerable <string> > config, string delimeter, string lastDelimeter)
{
return(config.Attach(ProcessingStep.WordJoin(delimeter, lastDelimeter)));
}
/// <summary>
/// Joins a series of strings.
/// </summary>
/// <param name="config">The config.</param>
/// <param name="delimeter">The delimeter.</param>
/// <returns></returns>
public static IForClause <string> TextJoin(this IForClause <IEnumerable <string> > config, string delimeter)
{
return(config.Attach(ProcessingStep.TextJoin(delimeter)));
}
/// <summary>
/// Invokes the LINQ method <code>Where</code> on the input.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="config">The config.</param>
/// <param name="predicate">The predicate.</param>
/// <returns></returns>
public static IForClause <IEnumerable <T> > Where <T>(this IForClause <IEnumerable <T> > config, Func <T, bool> predicate)
{
return(config.Attach(ProcessingStep.Where(predicate)));
}
/// <summary>
/// Invokes the LINQ method <code>Select</code> on the input.
/// </summary>
/// <typeparam name="TIn">The type of the in.</typeparam>
/// <typeparam name="TOut">The type of the out.</typeparam>
/// <param name="config">The config.</param>
/// <param name="selector">The selector.</param>
/// <returns></returns>
public static IForClause <IEnumerable <TOut> > Select <TIn, TOut>(this IForClause <IEnumerable <TIn> > config, Func <TIn, TOut> selector)
{
return(config.Attach(ProcessingStep.Select(selector)));
}
/// <summary>
/// Casts the value from one type to another.
/// </summary>
/// <typeparam name="TOut">The type of the cast.</typeparam>
/// <param name="config">The for clause to which the step is added.</param>
/// <returns></returns>
public static IForClause <TOut> As <TOut>(this IForClause config)
{
return(config.Attach(ProcessingStep.As <TOut>()));
}
/// <summary>
/// On for clauses that configure tokens with three inputs, performs a dynamically typed, arbitrary transformation that makes use of all inputs.
/// </summary>
/// <typeparam name = "TOut">The type of the output.</typeparam>
/// <param name="config">The for clause to which the step is added.</param>
/// <param name = "transform">The transformation.</param>
/// <returns></returns>
public static IForClause <TOut> Do3 <TOut>
(this IForClause <IMultiInput> config, Func <dynamic, dynamic, dynamic, TOut> transform)
{
return(config.Do3 <dynamic, dynamic, dynamic, TOut>(transform));
}
