public static TOutput RunCheckpoint <TInput, TOutput>(this ICheckpointRunner runner,
IAbstractCheckpoint <TInput, TOutput> wrapper,
TInput input,
ILoadingConvention <TInput, TOutput> loadingConvention)
{
return(runner.RunCheckpoint(wrapper.GetStepName(), wrapper.Run, input, loadingConvention));
}
public static TOutput RunCheckpoint <TInput, TOutput>(this ICheckpointRunner runner,
IAbstractCheckpoint <TInput, TOutput> wrapper,
TInput input,
INamingConvention <TOutput> namingConvention)
{
return(runner.RunCheckpoint(wrapper.GetStepName(), dir => wrapper.Run(input, dir), namingConvention));
}
public IParsingResult <IModeLauncher> Parse(
MainParser main, ILogger logger, ISettings settings, ICheckpointRunner checkpointRunner,
IWorkDoer workDoer, string[] args, TextWriter standardWriter, TextWriter errorWriter)
{
var results = main.GetParseResults(args);
var parsingResult = checkpointRunner.RunCheckpoint("Validate input", () =>
{
if (!results.Validate(out IParsingResult <IModeLauncher> failedResult))
{
return(ParsingResult <T> .FailedResult(failedResult.ErrorMessage));
}
var successfulResults = new SuccessfulResultCollection(results);
var commonOptions = successfulResults.Get(MainParser.CommonOptionsParser);
return(GetSerializedResult(successfulResults, commonOptions));
});
if (!parsingResult.Success)
{
ShowError(main, logger.Error, parsingResult.ErrorMessage);
return(ParsingResult <IModeLauncher> .FailedResult(parsingResult));
}
var runner = GetRunner(parsingResult.Result);
return(ParsingResult <IModeLauncher> .SuccessfulResult(new ModeLauncher(logger, settings, checkpointRunner, workDoer, runner, args, main.GetVersion(), Name)));
}
public static TOutput RunCheckpoint <TConvention, TInput, TOutput>(this ICheckpointRunner runner,
IMoveableResultCheckpoint <TConvention, TInput, TOutput> wrapper,
TInput input,
TConvention convention)
{
return(runner.RunCheckpoint(wrapper, input, wrapper.GetNamingConvention(convention)));
}
public static TResult RunCheckpoint <TResult>(this ICheckpointRunner runner, string name, Func <IDirectoryLocation, TResult> run, INamingConvention <TResult> namingConvention)
{
return(runner.RunCheckpoint(name, (dir, mover) =>
{
var result = run(dir);
return namingConvention.Move(result, mover.Move);
}));
}
public static TResult RunCheckpoint <TInput, TResult>(this ICheckpointRunner runner, string name, Func <TInput, IDirectoryLocation, TResult> run, TInput input, ILoadingConvention <TInput, TResult> loadingConvention)
{
return(runner.RunCheckpoint(name, (dir, mover) =>
{
var result = run(input, dir);
loadingConvention.Move(result, mover.Move);
return loadingConvention.Load(input);
}, () => loadingConvention.Load(input)));
}
public static Task <TOutput> RunCheckpointAsync <TOutput>(this ICheckpointRunner runner,
string key,
Func <IDirectoryLocation, TOutput> run,
INamingConvention <TOutput> namingConvention)
{
var asyncNamingConvention = new NamingConventionAsync <TOutput>(namingConvention);
return(runner.RunCheckpoint(key, dir => Task.Run(() => run(dir)), asyncNamingConvention));
}
public SampleSet <TCanvasOutput> Run(SampleSet <TCanvasInput> inputs, SampleStubNamingConvention sampleStubNamingConvention, ICheckpointRunner checkpointRunner)
{
return(checkpointRunner.RunCheckpoint(_canvasCheckpoint, inputs, sampleStubNamingConvention));
}
public static Task <TResult> RunCheckpointAsync <TResult>(this ICheckpointRunner checkpointRunner, string checkpointName, Func <IDirectoryLocation, IFileMover, TResult> function, Func <TResult> load)
{
return(checkpointRunner.RunCheckpoint(checkpointName, (tempDir, fileMover) => Task.Run(() => function(tempDir, fileMover)), () => Task.Run(load)));
}
public static Task <TResult> RunCheckpointAsync <TResult>(this ICheckpointRunner checkpointRunner, string key, Func <TResult> run, Func <TResult> load)
{
return(checkpointRunner.RunCheckpoint(key, () => Task.Run(run), () => Task.Run(load)));
}
public static Task <TResult> RunCheckpointAsync <TResult>(this ICheckpointRunner checkpointRunner, string checkpointName, Func <TResult> function)
{
return(checkpointRunner.RunCheckpoint(checkpointName, () => Task.Run(function)));
}
public static TResult RunCheckpoint <TResult>(this ICheckpointRunner checkpointRunner, string checkpointName, Func <ICheckpointRunner, IDirectoryLocation, IFileMover, TResult> run)
{
return(checkpointRunner.RunCheckpoint(checkpointName, (tempDir, fileMover) => run(checkpointRunner, tempDir, fileMover)));
}
/// <summary>
///
/// </summary>
/// <param name="runner"></param>
/// <param name="key"></param>
/// <param name="wrapper"></param>
/// <param name="input"></param>
/// <param name="loadingConvention"></param>
/// <typeparam name="TInput"></typeparam>
/// <typeparam name="TOutput"></typeparam>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public static Task <TOutput> RunCheckpointAsync <TInput, TOutput>(this ICheckpointRunner runner, string key, ISandboxedCheckpoint <TInput, TOutput> wrapper, TInput input, ILoadingConvention <TInput, TOutput> loadingConvention)
{
var asyncLoadingConvention = new LoadingConventionAsync <TInput, TOutput>(loadingConvention);
return(runner.RunCheckpoint(key, (tempInput, dir) => Task.Run(() => wrapper.Run(tempInput, dir)), input, asyncLoadingConvention));
}