seqan::ArgumentParser::ParseResult parseCommandLine(AppOptions & options, int argc, char const ** argv) { // Setup ArgumentParser. seqan::ArgumentParser parser("%(NAME)s"); // Set short description, version, and date. setShortDescription(parser, "Put a Short Description Here"); setVersion(parser, "0.1"); setDate(parser, "July 2012"); // Define usage line and long description. addUsageLine(parser, "[\\fIOPTIONS\\fP] \"\\fITEXT\\fP\""); addDescription(parser, "This is the application skelleton and you should modify this string."); // We require one argument. addArgument(parser, seqan::ArgParseArgument(seqan::ArgParseArgument::STRING, "TEXT")); addOption(parser, seqan::ArgParseOption("q", "quiet", "Set verbosity to a minimum.")); addOption(parser, seqan::ArgParseOption("v", "verbose", "Enable verbose output.")); addOption(parser, seqan::ArgParseOption("vv", "very-verbose", "Enable very verbose output.")); // Add Examples Section. addTextSection(parser, "Examples"); addListItem(parser, "\\fB%(NAME)s\\fP \\fB-v\\fP \\fItext\\fP", "Call with \\fITEXT\\fP set to \"text\" with verbose output."); // Parse command line. seqan::ArgumentParser::ParseResult res = seqan::parse(parser, argc, argv); // Only extract options if the program will continue after parseCommandLine() if (res != seqan::ArgumentParser::PARSE_OK) return res; // Extract option values. if (isSet(parser, "quiet")) options.verbosity = 0; if (isSet(parser, "verbose")) options.verbosity = 2; if (isSet(parser, "very-verbose")) options.verbosity = 3; seqan::getArgumentValue(options.text, parser, 0); return seqan::ArgumentParser::PARSE_OK; }
seqan::ArgumentParser::ParseResult parseCommandLine(ModifyStringOptions & options, int argc, char const ** argv) { // Setup ArgumentParser. seqan::ArgumentParser parser("modify_string"); // Set short description, version, and date. setShortDescription(parser, "String Modifier"); setVersion(parser, "1.0"); setDate(parser, "July 2012"); // Define usage line and long description. addUsageLine(parser, "[\\fIOPTIONS\\fP] \"\\fITEXT\\fP\""); addDescription(parser, "This program allows simple character modifications to " "each i-th character."); // We require one argument. addArgument(parser, seqan::ArgParseArgument( seqan::ArgParseArgument::STRING, "TEXT")); // Define Options -- Section Modification Options addSection(parser, "Modification Options"); addOption(parser, seqan::ArgParseOption( "i", "period", "Period to use for the index.", seqan::ArgParseArgument::INTEGER, "INT")); setDefaultValue(parser, "period", "1"); addOption(parser, seqan::ArgParseOption( "U", "uppercase", "Select to-uppercase as operation.")); addOption(parser, seqan::ArgParseOption( "L", "lowercase", "Select to-lowercase as operation.")); // Add Examples Section. addTextSection(parser, "Examples"); addListItem(parser, "\\fBmodify_string\\fP \\fB-U\\fP \\fIveryverylongword\\fP", "Print upper case version of \"veryverylongword\""); addListItem(parser, "\\fBmodify_string\\fP \\fB-L\\fP \\fB-i\\fP \\fI3\\fP " "\\fIveryverylongword\\fP", "Print \"veryverylongword\" with every third character " "converted to upper case."); // Parse command line. seqan::ArgumentParser::ParseResult res = seqan::parse(parser, argc, argv); // Only extract options if the program will continue after parseCommandLine() if (res != seqan::ArgumentParser::PARSE_OK) return res; // Extract option values. getOptionValue(options.period, parser, "period"); options.toUppercase = isSet(parser, "uppercase"); options.toLowercase = isSet(parser, "lowercase"); seqan::getArgumentValue(options.text, parser, 0); // If both to-uppercase and to-lowercase were selected then this is an error. if (options.toUppercase && options.toLowercase) { std::cerr << "ERROR: You cannot specify both to-uppercase and to-lowercase!\n"; return seqan::ArgumentParser::PARSE_ERROR; } return seqan::ArgumentParser::PARSE_OK; }
seqan::ArgumentParser::ParseResult parseArgs(FxFaidxOptions & options, int argc, char const ** argv) { seqan::ArgumentParser parser("fx_faidx"); setShortDescription(parser, "Indexing FASTA and indexed FASTA access."); setVersion(parser, "0.1"); setDate(parser, "May 2012"); addUsageLine(parser, "[\\fIOPTIONS\\fP] [\\fB-f\\fP \\fIFASTA\\fP] [\\fB-r\\fP \\fIREGION\\fP]+"); addDescription(parser, "Equivalent program to samtools faidx."); // TODO(holtgrew): I want a custom help text! // addOption(parser, seqan::ArgParseOption("h", "help", "This helpful screen.")); addOption(parser, seqan::ArgParseOption("v", "verbose", "Verbose, log to STDERR.")); addOption(parser, seqan::ArgParseOption("vv", "very-verbose", "Very verbose, log to STDERR.")); hideOption(parser, "very-verbose"); addSection(parser, "FASTA / FAIDX Files"); addOption(parser, seqan::ArgParseOption("f", "fasta-file", "Path to the FASTA file.", seqan::ArgParseArgument::STRING, false, "FASTA")); setRequired(parser, "fasta-file"); addOption(parser, seqan::ArgParseOption("i", "index-file", "Path to the .fai index file. Defaults to FASTA.fai", seqan::ArgParseArgument::STRING, false, "FASTA")); addOption(parser, seqan::ArgParseOption("o", "out-file", "Path to the resulting file. If omitted, result is printed to stdout.", seqan::ArgParseArgument::STRING, false, "FASTA")); addSection(parser, "Regions"); addOption(parser, seqan::ArgParseOption("r", "region", "Region to retrieve from FASTA file. You can specify multiple regions with multiple \\fB-r\\fP \\fIREGION\\fP. Note that regions are one-based, see below for detailed information about the format.", seqan::ArgParseArgument::STRING, true, "REGION")); addTextSection(parser, "Regions"); addText(parser, "Regions can be specified in the formats \\fICHR\\fP, \\fICHR\\fP:\\fISTART\\fP, \\fICHR\\fP:\\fISTART\\fP:\\fIEND\\fP. \\fICHR\\fP is the id of the reference sequence in the FASTA file, \\fISTART\\fP and \\fIEND\\fP are the start end end positions of the region. These positions are one-based."); addTextSection(parser, "Region Examples"); addListItem(parser, "\\fIchr1\\fP", "All of the sequence with the identifier \"chr1\"."); addListItem(parser, "\\fIchrX\\fP:\\fI1,000\\fP", "The characters in the X chromsome, starting with the 1,000th base."); addListItem(parser, "\\fIchr2\\fP:\\fI1,500,000\\fP-\\fI2,000,000\\fP", "The character 1,500,000 up to and including character 2,000,000 in the same chromosome."); addTextSection(parser, "Usage Examples"); addListItem(parser, "\\fBfx_faidx\\fP \\fB-f\\fP \\fIREF.fa\\fP", "Create index for file \\fIREF.fa\\fP, index is written to \\fIREF.fa.fai\\fP"); addListItem(parser, "\\fBfx_faidx\\fP \\fB-f\\fP \\fIREF.fa\\fP \\fB-i\\fP \\fIINDEX.fai\\fP", "Create index for file \\fIREF.fa\\fP, index is written to \\fIINDEX.fai\\fP"); addListItem(parser, "\\fBfx_faidx\\fP \\fB-f\\fP \\fIREF.fa\\fP \\fB-r\\fP \\fIchr1\\fP", "Retrieve sequence named \"chr1\" from file \\fIREF.fa\\fP using the index with the default name \\fIREF.fa.fai\\fP. The index file name is created if it does not exist."); addListItem(parser, "\\fBfx_faidx\\fP \\fB-f\\fP \\fIREF.fa\\fP \\fB-r\\fP \\fIchr1:100-1100\\fP", "Retrieve characters 100 to 1,100 from the sequence named \"chr1\" from file \\fIREF.fa\\fP using the index with the default name \\fIREF.fa.fai\\fP."); addListItem(parser, "\\fBfx_faidx\\fP \\fB-f\\fP \\fIREF.fa\\fP \\fB-r\\fP \\fIchr1:100-1100\\fP \\fB-r\\fP \\fIchr2:2,000\\fP", "Retrieve characters 100-1,000 from \"chr1\" and all characters from 2,000 of \"chr2\"."); seqan::ArgumentParser::ParseResult res = parse(parser, argc, argv); if (res == seqan::ArgumentParser::PARSE_OK) { getOptionValue(options.inFastaPath, parser, "fasta-file"); // Set default FAI file name. options.inFaiPath = options.inFastaPath; append(options.inFaiPath, ".fai"); // Get FAI file name from parser if set. if (isSet(parser, "index-file")) getOptionValue(options.inFaiPath, parser, "index-file"); if (isSet(parser, "region")) options.regions = getOptionValues(parser, "region"); if (isSet(parser, "out-file")) getOptionValue(options.outFastaPath, parser, "out-file"); if (isSet(parser, "verbose")) options.verbosity = 2; if (isSet(parser, "very-verbose")) options.verbosity = 3; } return res; }
seqan::ArgumentParser::ParseResult parseArgs(SakOptions & options, int argc, char ** argv) { seqan::ArgumentParser parser("sak"); setShortDescription(parser, "Slicing and dicing of FASTA/FASTQ files.."); setVersion(parser, SEQAN_APP_VERSION " [" SEQAN_REVISION "]"); setDate(parser, SEQAN_DATE); setCategory(parser, "Utilities"); addUsageLine(parser, "[\\fIOPTIONS\\fP] [\\fB-o\\fP \\fIOUT.{fa,fq}\\fP] \\fIIN.{fa,fq}\\fP"); addDescription(parser, "\"It slices, it dices and it makes the laundry!\""); addDescription(parser, "Original SAK tool by David Weese. Rewrite by Manuel Holtgrewe."); // The only argument is the input file. addArgument(parser, seqan::ArgParseArgument(seqan::ArgParseArgument::INPUT_FILE, "IN")); // Only FASTA and FASTQ files are allowed as input. setValidValues(parser, 0, seqan::SeqFileIn::getFileExtensions()); // TODO(holtgrew): I want a custom help text! // addOption(parser, seqan::ArgParseOption("h", "help", "This helpful screen.")); addOption(parser, seqan::ArgParseOption("v", "verbose", "Verbose, log to STDERR.")); hideOption(parser, "verbose"); addOption(parser, seqan::ArgParseOption("vv", "very-verbose", "Very verbose, log to STDERR.")); hideOption(parser, "very-verbose"); addSection(parser, "Output Options"); addOption(parser, seqan::ArgParseOption("o", "out-path", "Path to the resulting file. If omitted, result is printed to stdout in FastQ format.", seqan::ArgParseOption::OUTPUT_FILE, "FASTX")); setValidValues(parser, "out-path", seqan::SeqFileOut::getFileExtensions()); addOption(parser, seqan::ArgParseOption("rc", "revcomp", "Reverse-complement output.")); addOption(parser, seqan::ArgParseOption("l", "max-length", "Maximal number of sequence characters to write out.", seqan::ArgParseOption::INTEGER, "LEN")); addSection(parser, "Filter Options"); addOption(parser, seqan::ArgParseOption("s", "sequence", "Select the given sequence for extraction by 0-based index.", seqan::ArgParseOption::INTEGER, "NUM", true)); addOption(parser, seqan::ArgParseOption("sn", "sequence-name", "Select sequence with name prefix being \\fINAME\\fP.", seqan::ArgParseOption::STRING, "NAME", true)); addOption(parser, seqan::ArgParseOption("ss", "sequences", "Select sequences \\fIfrom\\fP-\\fIto\\fP where \\fIfrom\\fP and \\fIto\\fP " "are 0-based indices.", seqan::ArgParseArgument::STRING, "RANGE", true)); addOption(parser, seqan::ArgParseOption("i", "infix", "Select characters \\fIfrom\\fP-\\fIto\\fP where \\fIfrom\\fP and \\fIto\\fP " "are 0-based indices.", seqan::ArgParseArgument::STRING, "RANGE", true)); addOption(parser, seqan::ArgParseOption("ll", "line-length", "Set line length in output file. See section \\fILine Length\\fP for details.", seqan::ArgParseArgument::INTEGER, "LEN", false)); setMinValue(parser, "line-length", "-1"); addTextSection(parser, "Line Length"); addText(parser, "You can use the setting \\fB--line-length\\fP for setting the resulting line length. By default, " "sequences in FASTA files are written with at most 70 characters per line and sequences in FASTQ files are " "written without any line breaks. The quality sequence in FASTQ file is written in the same way as the " "residue sequence."); addText(parser, "The default is selected with a \\fB--line-length\\fP value of \\fI-1\\fP and line breaks can be disabled " "with a value of \\fI0\\fP."); addTextSection(parser, "Usage Examples"); addListItem(parser, "\\fBsak\\fP \\fB-s\\fP \\fI10\\fP \\fIIN.fa\\fP", "Cut out 11th sequence from \\fIIN.fa\\fP and write to stdout as FASTA."); addListItem(parser, "\\fBsak\\fP \\fB-ss\\fP \\fI10-12\\fP \\fB-ss\\fP \\fI100-200\\fP \\fIIN.fq\\fP", "Cut out 11th up to and including 12th and 101th up to and including 199th sequence from \\fIIN.fq\\fP " "and write to stdout as FASTA."); seqan::ArgumentParser::ParseResult res = parse(parser, argc, argv); if (res != seqan::ArgumentParser::PARSE_OK) return res; getArgumentValue(options.inFastxPath, parser, 0); seqan::CharString tmp; getOptionValue(tmp, parser, "out-path"); if (isSet(parser, "out-path")) getOptionValue(options.outPath, parser, "out-path"); if (isSet(parser, "verbose")) options.verbosity = 2; if (isSet(parser, "very-verbose")) options.verbosity = 3; if (isSet(parser, "sequence")) { std::vector<std::string> sequenceIds = getOptionValues(parser, "sequence"); for (unsigned i = 0; i < seqan::length(sequenceIds); ++i) { unsigned idx = 0; if (!seqan::lexicalCast(idx, sequenceIds[i])) { std::cerr << "ERROR: Invalid sequence index " << sequenceIds[i] << "\n"; return seqan::ArgumentParser::PARSE_ERROR; } appendValue(options.seqIndices, idx); } } if (isSet(parser, "sequences")) { std::vector<std::string> sequenceRanges = getOptionValues(parser, "sequences"); seqan::CharString buffer; for (unsigned i = 0; i < seqan::length(sequenceRanges); ++i) { seqan::Pair<uint64_t> range; if (!parseRange(range.i1, range.i2, sequenceRanges[i])) { std::cerr << "ERROR: Invalid range " << sequenceRanges[i] << "\n"; return seqan::ArgumentParser::PARSE_ERROR; } appendValue(options.seqIndexRanges, range); } } if (isSet(parser, "infix")) { seqan::CharString buffer; getOptionValue(buffer, parser, "infix"); if (!parseRange(options.seqInfixBegin, options.seqInfixEnd, buffer)) { std::cerr << "ERROR: Invalid range " << buffer << "\n"; return seqan::ArgumentParser::PARSE_ERROR; } } options.reverseComplement = isSet(parser, "revcomp"); if (isSet(parser, "max-length")) getOptionValue(options.maxLength, parser, "max-length"); if (isSet(parser, "sequence-name")) getOptionValue(options.readPattern, parser, "sequence-name"); getOptionValue(options.seqOutOptions.lineLength, parser, "line-length"); return res; }
seqan::ArgumentParser::ParseResult parseCommandLine(SeqConsOptions & options, int argc, char const ** argv) { // Setup ArgumentParser. seqan::ArgumentParser parser("seqcons2"); // Set short description, version, and date. setShortDescription(parser, "Compute consensus from sequences."); setVersion(parser, SEQAN_APP_VERSION " [" SEQAN_REVISION "]"); setDate(parser, SEQAN_DATE); // Define usage line and long description. addUsageLine(parser, "\\fB-i\\fP \\fIINPUT.{fa,sam}\\fP [\\fB-oa\\fP \\fIOUT_ALIGN.{fa,sam}\\fP] " "[\\fB-oc\\fP \\fIOUT_CONSENSUS.fa\\fP]"); addDescription(parser, "Compute consensus from sequences with and without approximate alignment information."); // Overall Program Options addOption(parser, seqan::ArgParseOption("q", "quiet", "Set verbosity to a minimum.")); addOption(parser, seqan::ArgParseOption("v", "verbose", "Enable verbose output.")); addOption(parser, seqan::ArgParseOption("vv", "very-verbose", "Enable very verbose output.")); addOption(parser, seqan::ArgParseOption("m", "method", "Method to perform. See section \\fIMethods\\fP " "below for details.", seqan::ArgParseOption::STRING, "METHOD")); setValidValues(parser, "method", "nop realign align_consensus overlap_consensus contig_consensus pos_consensus"); setDefaultValue(parser, "method", "pos_consensus"); // I/O Options addSection(parser, "I/O Options"); addOption(parser, seqan::ArgParseOption("i", "input-file", "Input file.", seqan::ArgParseOption::INPUT_FILE, "INPUT")); setRequired(parser, "input-file", true); setValidValues(parser, "input-file", "sam fa fasta"); addOption(parser, seqan::ArgParseOption("oa", "output-alignment-file", "Output file with alignment.", seqan::ArgParseOption::OUTPUT_FILE, "OUT_ALIGNMENT")); setRequired(parser, "output-alignment-file", false); setValidValues(parser, "output-alignment-file", "sam txt"); addOption(parser, seqan::ArgParseOption("oc", "output-consensus-file", "Output file with consensus sequence.", seqan::ArgParseOption::OUTPUT_FILE, "OUT_CONSENSUS")); setRequired(parser, "output-consensus-file", false); setValidValues(parser, "output-consensus-file", "fa fasta"); // Alignment Quality Filter Options addSection(parser, "Alignment Quality Filter Options"); addOption(parser, seqan::ArgParseOption("", "overlap-min-length", "Minimal overlap length.", seqan::ArgParseOption::INTEGER, "LENGTH")); setMinValue(parser, "overlap-min-length", "0"); setDefaultValue(parser, "overlap-min-length", "20"); addOption(parser, seqan::ArgParseOption("", "overlap-max-error", "Maximal error rate in overlap as percentage.", seqan::ArgParseOption::DOUBLE, "RATE")); setMinValue(parser, "overlap-max-error", "0.0"); setDefaultValue(parser, "overlap-max-error", "5.0"); addOption(parser, seqan::ArgParseOption("", "overlap-min-count", "Minimal overlap count.", seqan::ArgParseOption::INTEGER, "COUNT")); setMinValue(parser, "overlap-min-count", "0"); setDefaultValue(parser, "overlap-min-count", "3"); addOption(parser, seqan::ArgParseOption("", "overlap-window-size", "Window size to look for alignments.", seqan::ArgParseOption::INTEGER, "SIZE")); setMinValue(parser, "overlap-window-size", "0"); setDefaultValue(parser, "overlap-window-size", "20"); // K-mer Filter Options addSection(parser, "K-Mer Filter Options"); addOption(parser, seqan::ArgParseOption("", "k-mer-size", "The k-mer size to use.", seqan::ArgParseOption::INTEGER, "LENGTH")); setMinValue(parser, "k-mer-size", "5"); setDefaultValue(parser, "k-mer-size", "20"); addOption(parser, seqan::ArgParseOption("", "k-mer-max-occ", "Ignore k-mer with higher occurence count, 0 to disable.", seqan::ArgParseOption::INTEGER, "COUNT")); setMinValue(parser, "k-mer-max-occ", "0"); setDefaultValue(parser, "k-mer-max-occ", "200"); // Realignment Options addSection(parser, "Realignment Options"); addOption(parser, seqan::ArgParseOption("", "realign-bandwidth", "Bandwidth to use for pairwise alignments in realignment.", seqan::ArgParseOption::INTEGER, "LENGTH")); setMinValue(parser, "realign-bandwidth", "5"); setDefaultValue(parser, "realign-bandwidth", "10"); addOption(parser, seqan::ArgParseOption("", "realign-environment", "Environment for extraction in realignment.", seqan::ArgParseOption::INTEGER, "COUNT")); setMinValue(parser, "realign-environment", "5"); setDefaultValue(parser, "realign-environment", "20"); // Add Methods Section addTextSection(parser, "Methods"); addListItem(parser, "\\fBnop\\fP", "Perform no action, just perform file conversion if possible."); addListItem(parser, "\\fBrealign\\fP", "Perform realignment, requires input to be a SAM file to provide approximate position " "information, creates consensus sequence after realignment."); addListItem(parser, "\\fBoverlap_consensus\\fP", "Perform MSA with overlap alignments of the input ignoring any given coordinates, then realign. " "This is most suited when computing the consensus of reads where the underlying sequence is very " "similar and most differences stem from sequencing errors and not genomic variation. All " "pairwise alignments computed here are banded."); addListItem(parser, "\\fBalign_consensus\\fP", "Perform MSA with global alignments of the input ignoring any given coordinates, then realign. " "This will computed unbanded global ends-gap free pairwise alignments. This is also suitable " "when aligning different sequences, e.g. clustered transcripts. Using this method, seqcons " "will be similar to calling SeqAn::T-Coffee, followed by realignment and consensus computation."); addListItem(parser, "\\fBcontig_consensus\\fP", "Perform MSA of the input, contig by contig, requires contig information, then realign. Input " "must be SAM."); addListItem(parser, "\\fBpos_consensus\\fP", "Perform consensus of the input, then realign. Requires approximate coordinate information in " "SAM file."); // Add Output Section addTextSection(parser, "Output Formats"); addText(parser, "The program can write out the consensus sequence in FASTA format and optionally the alignment of the " "input sequences against the consensus in SAM/BAM format. When using the extension \\fI.txt\\fP, seqcons " "will write out the MSA as a plain text visualization."); // Add Examples Section addTextSection(parser, "Examples"); addListItem(parser, "\\fBseqcons\\fP \\fB-m\\fP \\fIovl_consensus\\fP \\fB-i\\fP \\fIreads.fa\\fP \\fB-oa\\fP " "\\fIout.sam\\fP \\fB-oc\\fP \\fIcons.fa\\fP", "Compute MSA of the sequences in \\fIreads.fa\\fP. The consensus sequence is written to " "\\fIcons.fa\\fP and the alignment of the sequences in \\fIreads.fa\\fP is written to " "\\fIout.sam\\fP."); addListItem(parser, "\\fBseqcons\\fP \\fB-m\\fP \\fIrealign\\fP \\fB-i\\fP \\fIin.sam\\fP \\fB-oa\\fP \\fIout.sam\\fP", "Read in multi-read alignment from \\fIin.sam\\fP, refine it using Anson-Myers realignment and " "write out the refined alignment to \\fIout.sam\\fP"); // Parse command line. seqan::ArgumentParser::ParseResult res = seqan::parse(parser, argc, argv); // Only extract options if the program will continue after parseCommandLine() if (res != seqan::ArgumentParser::PARSE_OK) return res; // Extract option values. if (isSet(parser, "quiet")) options.verbosity = 0; if (isSet(parser, "verbose")) options.verbosity = 2; if (isSet(parser, "very-verbose")) options.verbosity = 3; std::string opStr; getOptionValue(opStr, parser, "method"); options.operation = strToMethod(opStr.c_str()); getOptionValue(options.inputFile, parser, "input-file"); getOptionValue(options.outputFileAlignment, parser, "output-alignment-file"); getOptionValue(options.outputFileConsensus, parser, "output-consensus-file"); getOptionValue(options.overlapMinLength, parser, "overlap-min-length"); getOptionValue(options.overlapMaxErrorRate, parser, "overlap-max-error"); getOptionValue(options.overlapWindowSize, parser, "overlap-window-size"); getOptionValue(options.kMerSize, parser, "k-mer-size"); getOptionValue(options.kMerMaxOcc, parser, "k-mer-max-occ"); getOptionValue(options.reAlignmentBandwidth, parser, "realign-bandwidth"); getOptionValue(options.reAlignmentEnvironment, parser, "realign-environment"); return seqan::ArgumentParser::PARSE_OK; }
seqan::ArgumentParser::ParseResult parseCommandLine(MasonGenomeOptions & options, int argc, char const ** argv) { // Setup ArgumentParser. seqan::ArgumentParser parser("mason_genome"); // Set short description, version, and date. setShortDescription(parser, "Random Genome Simulation"); setVersion(parser, "2.1"); setDate(parser, "March 2013"); setCategory(parser, "Simulators"); // Define usage line and long description. addUsageLine(parser, "[\\fIOPTIONS\\fP] [\\fB-l\\fP \\fILEN\\fP]+ \\fB-o\\fP \\fIOUT.fa\\fP"); addDescription(parser, "Simulate a random genome to the output file. For each \\fB-l\\fP/\\fB--contig-length\\fP " "entry, a contig with the given length will be simulated."); // We require one argument. addOption(parser, seqan::ArgParseOption("q", "quiet", "Set verbosity to a minimum.")); addOption(parser, seqan::ArgParseOption("v", "verbose", "Enable verbose output.")); addOption(parser, seqan::ArgParseOption("vv", "very-verbose", "Enable very verbose output.")); addSection(parser, "Simulation Configuration"); addOption(parser, seqan::ArgParseOption("l", "contig-length", "Length of the contig to simulate. Give one \\fB-l\\fP " "value for each contig to simulate.", seqan::ArgParseOption::INTEGER, "LENGTH", true)); setMinValue(parser, "contig-length", "1"); setRequired(parser, "contig-length"); addOption(parser, seqan::ArgParseOption("s", "seed", "The seed to use for the random number generator.", seqan::ArgParseOption::INTEGER, "INT")); setDefaultValue(parser, "seed", 0); addSection(parser, "Output Options"); addOption(parser, seqan::ArgParseOption("o", "out-file", "Output file.", seqan::ArgParseOption::OUTPUTFILE, "FILE")); setValidValues(parser, "out-file", "fa fasta"); setRequired(parser, "out-file"); // Add Examples Section. addTextSection(parser, "Examples"); addListItem(parser, "\\fBmason_genome\\fP \\fB-l\\fP 1000 \\fB-l\\fP 4000 \\fB-o\\fP \\fIgenome.fa\\fP", "Simulate a genome with two contigs of lengths 1000 and 4000 and write it to genome.fa."); // Parse command line. seqan::ArgumentParser::ParseResult res = seqan::parse(parser, argc, argv); // Only extract options if the program will continue after parseCommandLine() if (res != seqan::ArgumentParser::PARSE_OK) return res; // Extract option values. if (isSet(parser, "quiet")) options.verbosity = 0; if (isSet(parser, "verbose")) options.verbosity = 2; if (isSet(parser, "very-verbose")) options.verbosity = 3; getOptionValue(options.outputFilename, parser, "out-file"); getOptionValue(options.seed, parser, "seed"); for (unsigned i = 0; i < getOptionValueCount(parser, "contig-length"); ++i) { int len = 0; getOptionValue(len, parser, "contig-length", i); appendValue(options.contigLengths, len); } return seqan::ArgumentParser::PARSE_OK; }