public override IParsingResult <GermlineWgsInput> GetSerializedResult(SuccessfulResultCollection result, CommonOptions commonOptions)
{
var singleSampleCommonOptions = result.Get(SingleSampleCommonOptionsParser);
var bam = result.Get(Bam);
return(ParsingResult <GermlineWgsInput> .SuccessfulResult(new GermlineWgsInput(commonOptions, singleSampleCommonOptions, bam)));
}
public override ParsingResult <IModeRunner> Parse(SuccessfulResultCollection parseInput)
{
CommonOptions commonOptions = parseInput.Get(CommonOptionsParser);
TumorNormalOptions tumorNormalOptions = parseInput.Get(TumorNormalOptionsParser);
return(ParsingResult <IModeRunner> .SuccesfulResult(new TumorNormalWgsRunner(commonOptions, tumorNormalOptions)));
}
public override ParsingResult <SomaticEnrichmentOptions> Parse(SuccessfulResultCollection parseInput)
{
var bam = parseInput.Get(Bam);
var manifest = parseInput.Get(Manifest);
var controlBams = parseInput.Get(ControlBams);
var controlBinned = parseInput.Get(ControlBinned);
var controlBinSize = parseInput.Get(ControlBinSize);
var controlPloidy = parseInput.Get(ControlPloidyBed);
var controlBinnedBools = new List <bool> {
controlBinned != null, controlBinSize != null, controlPloidy != null
};
if (controlBams.Any() && controlBinnedBools.Any(controlBinnedBool => controlBinnedBool))
{
return(ParsingResult <SomaticEnrichmentOptions> .FailedResult($"Error: option {ControlBams.Info.Name} cannot be combined with any of {ControlBinned.Info.Name}, {ControlBinSize.Info.Name}, {ControlPloidyBed.Info.Name} "));
}
if (controlBinned != null && controlBinSize == null)
{
return(ParsingResult <SomaticEnrichmentOptions> .FailedResult($"Error: {ControlBinSize.Info.Name} is required when using the {ControlBinned.Info.Name} option"));
}
return(ParsingResult <SomaticEnrichmentOptions> .SuccesfulResult(
new SomaticEnrichmentOptions(
bam,
manifest,
controlBams,
controlBinned,
controlBinSize.HasValue ? (int)controlBinSize.Value : 0,
controlPloidy)));
}
public override ParsingResult <IModeRunner> Parse(SuccessfulResultCollection parseInput)
{
CommonOptions commonOptions = parseInput.Get(CommonOptionsParser);
SomaticEnrichmentOptions somaticEnrichmentOptions = parseInput.Get(SomaticEnrichmentOptionsParser);
return(ParsingResult <IModeRunner> .SuccesfulResult(new SomaticEnrichmentRunner(commonOptions, somaticEnrichmentOptions)));
}
public override ParsingResult <IModeRunner> Parse(SuccessfulResultCollection parseInput)
{
CommonOptions commonOptions = parseInput.Get(CommonOptionsParser);
var bam = parseInput.Get(Bam);
return(ParsingResult <IModeRunner> .SuccesfulResult(new GermlineWgsRunner(commonOptions, bam)));
}
public override IParsingResult <BaseOptions> Parse(SuccessfulResultCollection parseInput)
{
var helpResult = parseInput.Get(Help);
var versionResult = parseInput.Get(Version);
return(ParsingResult <BaseOptions> .SuccessfulResult(new BaseOptions(helpResult, versionResult)));
}
public override ParsingResult <IModeRunner> Parse(SuccessfulResultCollection parseInput)
{
CommonOptions commonOptions = parseInput.Get(CommonOptionsParser);
SmallPedigreeOptions smallPedigreeOptions = parseInput.Get(SmallPedigreeOptionsParser);
return(ParsingResult <IModeRunner> .SuccessfulResult(new SmallPedigreeWgsRunner(commonOptions, smallPedigreeOptions)));
}
public override IParsingResult <ExclusiveFileOptionResult> Parse(SuccessfulResultCollection parseInput)
{
var result1 = parseInput.Get(_option1);
var result2 = parseInput.Get(_option2);
if (result1 != null && result2 != null)
{
return(ParsingResult <ExclusiveFileOptionResult> .FailedResult($"Please specify either option {_option1.Info.Name} or option {_option2.Info.Name}, but not both"));
}
if (_isRequired && result1 == null && result2 == null)
{
return(ParsingResult <ExclusiveFileOptionResult> .FailedResult($"Either option {_option1.Info.Name} or option {_option2.Info.Name} must be specified"));
}
IFileLocation result = null;
FileOption option = null;
if (result1 != null)
{
result = result1;
option = _option1;
}
if (result2 != null)
{
result = result2;
option = _option2;
}
return(ParsingResult <ExclusiveFileOptionResult> .SuccessfulResult(new ExclusiveFileOptionResult(result, option)));
}
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 override IParsingResult <List <TOut> > Parse(SuccessfulResultCollection input)
{
var multipleValues = input.Get(Info);
var outputs = new List <TOut>();
foreach (var values in multipleValues)
{
var option1Result = GetOptionResult(0, values, _option1);
var option2Result = GetOptionResult(1, values, _option2);
var option3Result = GetOptionResult(2, values, _option3);
if (!option1Result.Success)
{
return(ParsingResult <List <TOut> > .FailedResult(option1Result.ErrorMessage));
}
if (!option2Result.Success)
{
return(ParsingResult <List <TOut> > .FailedResult(option2Result.ErrorMessage));
}
if (!option3Result.Success)
{
return(ParsingResult <List <TOut> > .FailedResult(option3Result.ErrorMessage));
}
var result = _parse(option1Result.Result, option2Result.Result, option3Result.Result);
if (!result.Success)
{
return(ParsingResult <List <TOut> > .FailedResult(result.ErrorMessage));
}
outputs.Add(result.Result);
}
if (_required && outputs.Empty())
{
return(ParsingResult <List <TOut> > .FailedResult($"{Info.Name} is a required option"));
}
return(ParsingResult <List <TOut> > .SuccessfulResult(outputs));
}
public override ParsingResult <CommonOptions> Parse(SuccessfulResultCollection parseInput)
{
var bAlleleSites = parseInput.Get(BAlleleSites);
bool isDbSnpVcf = parseInput.Get(IsDbSnpVcf);
var ploidyBed = parseInput.Get(PloidyBed);
var output = parseInput.Get(Output);
var wholeGenomeFasta = parseInput.Get(WholeGenomeFasta);
var kmerFasta = parseInput.Get(KmerFasta);
var filterBed = parseInput.Get(FilterFile);
var sampleName = parseInput.Get(SampleName);
var customParameters = parseInput.Get(CustomParameters);
string startCheckpoint = parseInput.Get(StartCheckpoint);
string stopCheckpoint = parseInput.Get(StopCheckpoint);
return(ParsingResult <CommonOptions> .SuccesfulResult(
new CommonOptions(
bAlleleSites,
isDbSnpVcf,
ploidyBed,
output,
wholeGenomeFasta,
kmerFasta,
filterBed,
sampleName,
customParameters,
startCheckpoint,
stopCheckpoint)));
}
public override ParsingResult<IModeRunner> Parse(SuccessfulResultCollection parseInput)
{
CommonOptions commonOptions = parseInput.Get(CommonOptionsParser);
TumorNormalOptions tumorNormalOptions = parseInput.Get(TumorNormalOptionsParser);
var normalBam = parseInput.Get(NormalBam);
var manifest = parseInput.Get(Manifest);
return ParsingResult<IModeRunner>.SuccesfulResult(new TumorNormalEnrichmentRunner(commonOptions, tumorNormalOptions, normalBam, manifest));
}
public override IParsingResult <TumorNormalWgsInput> GetSerializedResult(SuccessfulResultCollection result, CommonOptions commonOptions)
{
var singleSampleCommonOptions = result.Get(SingleSampleCommonOptionsParser);
TumorNormalOptions tumorNormalOptions = result.Get(TumorNormalOptionsParser);
return(ParsingResult <TumorNormalWgsInput> .SuccessfulResult(
new TumorNormalWgsInput(commonOptions, singleSampleCommonOptions, tumorNormalOptions)));
}
public override ParsingResult <TumorNormalOptions> Parse(SuccessfulResultCollection parseInput)
{
var tumorBam = parseInput.Get(TumorBam);
var somaticVcf = parseInput.Get(SomaticVcf);
return(ParsingResult <TumorNormalOptions> .SuccesfulResult(
new TumorNormalOptions(tumorBam, somaticVcf)));
}
public override IParsingResult <SomaticEnrichmentInput> GetSerializedResult(SuccessfulResultCollection result, CommonOptions commonOptions)
{
SomaticEnrichmentOptions somaticEnrichmentOptions = result.Get(SomaticEnrichmentOptionsParser);
SingleSampleCommonOptions singleSampleCommonOptions = result.Get(SingleSampleCommonOptionsParser);
return(ParsingResult <SomaticEnrichmentInput> .SuccessfulResult(
new SomaticEnrichmentInput(commonOptions, somaticEnrichmentOptions, singleSampleCommonOptions)));
}
public override ParsingResult <IModeRunner> Parse(SuccessfulResultCollection parseInput)
{
CommonOptions commonOptions = parseInput.Get(CommonOptionsParser);
TumorNormalOptions tumorNormalOptions = parseInput.Get(TumorNormalOptionsParser);
var normalBam = parseInput.Get(NormalBam);
var manifest = parseInput.Get(Manifest);
return(ParsingResult <IModeRunner> .SuccesfulResult(new TumorNormalEnrichmentRunner(commonOptions, tumorNormalOptions, normalBam, manifest)));
}
public override ParsingResult <List <string> > Parse(SuccessfulResultCollection parseInput)
{
List <string> value = parseInput.Get(this);
if (!value.Any())
{
return(ParsingResult <List <string> > .FailedResult($"Error: {Name} is a required option"));
}
return(ParsingResult <List <string> > .SuccessfulResult(value));
}
public override ParsingResult <string> Parse(SuccessfulResultCollection parseInput)
{
string value = parseInput.Get(this);
if (value == null)
{
return(ParsingResult <string> .FailedResult($"Error: {Name} is a required option"));
}
return(ParsingResult <string> .SuccessfulResult(value));
}
public override IParsingResult <TOut> Parse(SuccessfulResultCollection parseInput)
{
var multipleValues = parseInput.Get(PositionalOption);
if (multipleValues.Count > 1)
{
return(ParsingResult <TOut> .FailedResult($"{PositionalOption.Info.Name} can be specified only once"));
}
return(ParsingResult <TOut> .SuccessfulResult(multipleValues.SingleOrDefault()));
}
public override IParsingResult <SingleSampleCommonOptions> Parse(SuccessfulResultCollection parseInput)
{
var bAlleleSites = parseInput.Get(BAlleleSites);
bool isDbSnpVcf = bAlleleSites.MatchedOption.Equals(PopulationBAlleleSites);
var ploidyVcf = parseInput.Get(PloidyVcf);
var sampleName = parseInput.Get(SampleName);
return(ParsingResult <SingleSampleCommonOptions> .SuccessfulResult(
new SingleSampleCommonOptions(
bAlleleSites.Result,
isDbSnpVcf,
ploidyVcf,
sampleName)));
}
public override IParsingResult <SmallPedigreeOptions> Parse(SuccessfulResultCollection parseInput)
{
var bams = parseInput.Get(Bams);
var ploidyVcf = parseInput.Get(PloidyVcf);
var bAlleleSites = parseInput.Get(BAlleleSites);
var commonCnvsBed = parseInput.Get(CommonCnvsBed);
IParsingResult <SmallPedigreeOptions> failedResult;
if (HasMoreThanOneSameSampleType(bams, out failedResult))
{
return(failedResult);
}
return(ParsingResult <SmallPedigreeOptions> .SuccessfulResult(new SmallPedigreeOptions(bams, commonCnvsBed, bAlleleSites.Result, bAlleleSites.MatchedOption.Equals(PopulationBAlleleSites), ploidyVcf)));
}
public override ParsingResult <List <T> > Parse(SuccessfulResultCollection input)
{
var values = input.Get(Info);
var results = new List <T>();
foreach (var value in values)
{
var result = _valueOption.Parse(value);
if (!result.Success)
{
return(ParsingResult <List <T> > .FailedResult(result.ErrorMessage));
}
results.Add(result.Result);
}
return(ParsingResult <List <T> > .SuccesfulResult(results));
}
public override IParsingResult <CommonOptions> Parse(SuccessfulResultCollection parseInput)
{
var output = parseInput.Get(Output);
var wholeGenomeFasta = parseInput.Get(WholeGenomeFasta);
var kmerFasta = parseInput.Get(KmerFasta);
var filterBed = parseInput.Get(FilterFile);
var customParameters = parseInput.Get(CustomParameters);
string startCheckpoint = parseInput.Get(StartCheckpoint);
string stopCheckpoint = parseInput.Get(StopCheckpoint);
return(ParsingResult <CommonOptions> .SuccessfulResult(
new CommonOptions(
output,
wholeGenomeFasta,
kmerFasta,
filterBed,
customParameters,
startCheckpoint,
stopCheckpoint)));
}
public override ParsingResult <SmallPedigreeOptions> Parse(SuccessfulResultCollection parseInput)
{
var bams = parseInput.Get(Bams);
var sampleNameToBam = MapSampleNameToBam(bams);
var ploidyVcf = parseInput.Get(PloidyVcf);
var bAlleleSites = parseInput.Get(BAlleleSites);
var mother = parseInput.Get(Mother);
var father = parseInput.Get(Father);
var proband = parseInput.Get(Proband);
var commonCnvsBed = parseInput.Get(CommonCnvsBed);
List <SmallPedigreeSampleOptions> samples = new List <SmallPedigreeSampleOptions>();
foreach (var sample in sampleNameToBam)
{
var sampleType = GetSampleType(sample.Key, mother, father, proband);
samples.Add(new SmallPedigreeSampleOptions(sample.Key, sampleType, sample.Value));
}
return(ParsingResult <SmallPedigreeOptions> .SuccessfulResult(new SmallPedigreeOptions(samples, commonCnvsBed, bAlleleSites.Result, bAlleleSites.MatchedOption.Equals(PopulationBAlleleSites), ploidyVcf)));
}
public override ParsingResult <Dictionary <string, string> > Parse(SuccessfulResultCollection parseInput)
{
List <string> inputs = parseInput.Get(_option);
var result = new Dictionary <string, string>();
foreach (var input in inputs)
{
string[] split = input.Split(_separator).Select(untrimmed => untrimmed.Trim()).ToArray();
if (split.Length != 2)
{
return(ParsingResult <Dictionary <string, string> > .FailedResult($"Error: expected format is {{KEY}}{_separator}{{value}}. Input was {input}"));
}
string key = split[0];
string value = split[1];
if (result.ContainsKey(key))
{
return(ParsingResult <Dictionary <string, string> > .FailedResult($"Error parsing {_option.Info.Name}: found duplicate key {key}"));
}
result.Add(key, value);
}
return(ParsingResult <Dictionary <string, string> > .SuccesfulResult(result));
}
IParsingResult IOption.Parse(SuccessfulResultCollection parseInput)
{
return(Parse(parseInput));
}
public override ParsingResult <T> Parse(SuccessfulResultCollection value)
{
return(Parse(value.Get(Info)));
}
public override ParsingResult<IModeRunner> Parse(SuccessfulResultCollection parseInput)
{
CommonOptions commonOptions = parseInput.Get(CommonOptionsParser);
var bam = parseInput.Get(Bam);
return ParsingResult<IModeRunner>.SuccesfulResult(new GermlineWgsRunner(commonOptions, bam));
}
public override IParsingResult <SmallPedigreeInput> GetSerializedResult(SuccessfulResultCollection result, CommonOptions commonOptions)
{
var smallPedigreeOptions = result.Get(SmallPedigreeOptionsParser);
return(ParsingResult <SmallPedigreeInput> .SuccessfulResult(new SmallPedigreeInput(commonOptions, smallPedigreeOptions)));
}
public abstract IParsingResult <TParseOutput> Parse(SuccessfulResultCollection parseInput);
public override ParsingResult <bool> Parse(SuccessfulResultCollection parseInput)
{
return(Parse(parseInput.Get(_info)));
}
public override ParsingResult <T> Parse(SuccessfulResultCollection parseInput)
{
return(ParsingResult <T> .SuccessfulResult(parseInput.Get(this)));
}
