exit(1);
}
}
-
-
+//**********************************************************************************************************************
+string RemoveLineageCommand::getOutputFileNameTag(string type, string inputName=""){
+ try {
+ string outputFileName = "";
+ map<string, vector<string> >::iterator it;
+
+ //is this a type this command creates
+ it = outputTypes.find(type);
+ if (it == outputTypes.end()) { m->mothurOut("[ERROR]: this command doesn't create a " + type + " output file.\n"); }
+ else {
+ if (type == "fasta") { outputFileName = "pick" + m->getExtension(inputName); }
+ else if (type == "taxonomy") { outputFileName = "pick" + m->getExtension(inputName); }
+ else if (type == "name") { outputFileName = "pick" + m->getExtension(inputName); }
+ else if (type == "group") { outputFileName = "pick" + m->getExtension(inputName); }
+ else if (type == "list") { outputFileName = "pick" + m->getExtension(inputName); }
+ else if (type == "alignreport") { outputFileName = "pick.align.report"; }
+ else { m->mothurOut("[ERROR]: No definition for type " + type + " output file tag.\n"); m->control_pressed = true; }
+ }
+ return outputFileName;
+ }
+ catch(exception& e) {
+ m->errorOut(e, "RemoveLineageCommand", "getOutputFileNameTag");
+ exit(1);
+ }
+}
//**********************************************************************************************************************
RemoveLineageCommand::RemoveLineageCommand(){
try {
//check for required parameters
fastafile = validParameter.validFile(parameters, "fasta", true);
- if (fastafile == "not open") { abort = true; }
+ if (fastafile == "not open") { fastafile = ""; abort = true; }
else if (fastafile == "not found") { fastafile = ""; }
+ else { m->setFastaFile(fastafile); }
namefile = validParameter.validFile(parameters, "name", true);
- if (namefile == "not open") { abort = true; }
+ if (namefile == "not open") { namefile = ""; abort = true; }
else if (namefile == "not found") { namefile = ""; }
+ else { m->setNameFile(namefile); }
groupfile = validParameter.validFile(parameters, "group", true);
if (groupfile == "not open") { abort = true; }
else if (groupfile == "not found") { groupfile = ""; }
+ else { m->setGroupFile(groupfile); }
alignfile = validParameter.validFile(parameters, "alignreport", true);
if (alignfile == "not open") { abort = true; }
listfile = validParameter.validFile(parameters, "list", true);
if (listfile == "not open") { abort = true; }
else if (listfile == "not found") { listfile = ""; }
+ else { m->setListFile(listfile); }
taxfile = validParameter.validFile(parameters, "taxonomy", true);
- if (taxfile == "not open") { abort = true; }
+ if (taxfile == "not open") { taxfile = ""; abort = true; }
else if (taxfile == "not found") {
taxfile = m->getTaxonomyFile();
if (taxfile != "") { m->mothurOut("Using " + taxfile + " as input file for the taxonomy parameter."); m->mothurOutEndLine(); }
else { m->mothurOut("You have no current taxonomy file and the taxonomy parameter is required."); m->mothurOutEndLine(); abort = true; }
- }
+ }else { m->setTaxonomyFile(taxfile); }
string usedDups = "true";
string temp = validParameter.validFile(parameters, "dups", false);
if (taxons[0] == '\'') { taxons = taxons.substr(1); }
if (taxons[(taxons.length()-1)] == '\'') { taxons = taxons.substr(0, (taxons.length()-1)); }
}
-
+ m->splitAtChar(taxons, listOfTaxons, '-');
if ((fastafile == "") && (namefile == "") && (groupfile == "") && (alignfile == "") && (listfile == "") && (taxfile == "")) { m->mothurOut("You must provide one of the following: fasta, name, group, alignreport, taxonomy or listfile."); m->mothurOutEndLine(); abort = true; }
if ((usedDups != "") && (namefile == "")) { m->mothurOut("You may only use dups with the name option."); m->mothurOutEndLine(); abort = true; }
-
+
+ if ((namefile == "") && ((fastafile != "") || (taxfile != ""))){
+ vector<string> files; files.push_back(fastafile); files.push_back(taxfile);
+ parser.getNameFile(files);
+ }
+
}
}
if (listfile != "") { readList(); }
- if (m->control_pressed) { for (int i = 0; i < outputNames.size(); i++) { remove(outputNames[i].c_str()); } return 0; }
+ if (m->control_pressed) { for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
if (outputNames.size() != 0) {
m->mothurOutEndLine();
try {
string thisOutputDir = outputDir;
if (outputDir == "") { thisOutputDir += m->hasPath(fastafile); }
- string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(fastafile)) + "pick" + m->getExtension(fastafile);
-
+ string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(fastafile)) + getOutputFileNameTag("fasta", fastafile);
ofstream out;
m->openOutputFile(outputFileName, out);
bool wroteSomething = false;
while(!in.eof()){
- if (m->control_pressed) { in.close(); out.close(); remove(outputFileName.c_str()); return 0; }
+ if (m->control_pressed) { in.close(); out.close(); m->mothurRemove(outputFileName); return 0; }
Sequence currSeq(in);
name = currSeq.getName();
try {
string thisOutputDir = outputDir;
if (outputDir == "") { thisOutputDir += m->hasPath(listfile); }
- string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(listfile)) + "pick" + m->getExtension(listfile);
-
+ string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(listfile)) + getOutputFileNameTag("list", listfile);
ofstream out;
m->openOutputFile(outputFileName, out);
//for each bin
for (int i = 0; i < list.getNumBins(); i++) {
- if (m->control_pressed) { in.close(); out.close(); remove(outputFileName.c_str()); return 0; }
+ if (m->control_pressed) { in.close(); out.close(); m->mothurRemove(outputFileName); return 0; }
//parse out names that are in accnos file
string binnames = list.get(i);
try {
string thisOutputDir = outputDir;
if (outputDir == "") { thisOutputDir += m->hasPath(namefile); }
- string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(namefile)) + "pick" + m->getExtension(namefile);
-
+ string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(namefile)) + getOutputFileNameTag("name", namefile);
ofstream out;
m->openOutputFile(outputFileName, out);
bool wroteSomething = false;
while(!in.eof()){
- if (m->control_pressed) { in.close(); out.close(); remove(outputFileName.c_str()); return 0; }
+ if (m->control_pressed) { in.close(); out.close(); m->mothurRemove(outputFileName); return 0; }
in >> firstCol;
in >> secondCol;
try {
string thisOutputDir = outputDir;
if (outputDir == "") { thisOutputDir += m->hasPath(groupfile); }
- string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(groupfile)) + "pick" + m->getExtension(groupfile);
-
+ string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(groupfile)) + getOutputFileNameTag("group", groupfile);
ofstream out;
m->openOutputFile(outputFileName, out);
bool wroteSomething = false;
while(!in.eof()){
- if (m->control_pressed) { in.close(); out.close(); remove(outputFileName.c_str()); return 0; }
+ if (m->control_pressed) { in.close(); out.close(); m->mothurRemove(outputFileName); return 0; }
in >> name; //read from first column
in >> group; //read from second column
try {
string thisOutputDir = outputDir;
if (outputDir == "") { thisOutputDir += m->hasPath(taxfile); }
- string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(taxfile)) + "pick" + m->getExtension(taxfile);
+ string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(taxfile)) + getOutputFileNameTag("taxonomy", taxfile);
ofstream out;
m->openOutputFile(outputFileName, out);
bool wroteSomething = false;
- bool taxonsHasConfidence = false;
- vector< map<string, float> > searchTaxons;
- string noConfidenceTaxons = taxons;
- int hasConPos = taxons.find_first_of('(');
- if (hasConPos != string::npos) {
- taxonsHasConfidence = true;
- searchTaxons = getTaxons(taxons);
- noConfidenceTaxons = removeConfidences(taxons);
+ vector<bool> taxonsHasConfidence; taxonsHasConfidence.resize(listOfTaxons.size(), false);
+ vector< vector< map<string, float> > > searchTaxons; searchTaxons.resize(listOfTaxons.size());
+ vector<string> noConfidenceTaxons; noConfidenceTaxons.resize(listOfTaxons.size(), "");
+
+ for (int i = 0; i < listOfTaxons.size(); i++) {
+ noConfidenceTaxons[i] = listOfTaxons[i];
+ int hasConPos = listOfTaxons[i].find_first_of('(');
+ if (hasConPos != string::npos) {
+ taxonsHasConfidence[i] = true;
+ searchTaxons[i] = getTaxons(listOfTaxons[i]);
+ noConfidenceTaxons[i] = listOfTaxons[i];
+ m->removeConfidences(noConfidenceTaxons[i]);
+ }
}
while(!in.eof()){
- if (m->control_pressed) { in.close(); out.close(); remove(outputFileName.c_str()); return 0; }
+ if (m->control_pressed) { in.close(); out.close(); m->mothurRemove(outputFileName); return 0; }
in >> name; //read from first column
in >> tax; //read from second column
- string newtax = tax;
+ bool remove = false;
- //if the users file contains confidence scores we want to ignore them when searching for the taxons, unless the taxon has them
- if (!taxonsHasConfidence) {
+ for (int j = 0; j < listOfTaxons.size(); j++) {
+ string newtax = tax;
- int hasConfidences = tax.find_first_of('(');
- if (hasConfidences != string::npos) {
- newtax = removeConfidences(tax);
- }
-
- int pos = newtax.find(taxons);
-
- if (pos == string::npos) {
- wroteSomething = true;
- out << name << '\t' << tax << endl;
- }else{ //this sequence contains the taxon the user wants to remove
- names.insert(name);
- }
-
- }else{//if taxons has them and you don't them remove taxons
- int hasConfidences = tax.find_first_of('(');
- if (hasConfidences == string::npos) {
-
- int pos = newtax.find(noConfidenceTaxons);
+ //if the users file contains confidence scores we want to ignore them when searching for the taxons, unless the taxon has them
+ if (!taxonsHasConfidence[j]) {
- if (pos == string::npos) {
- wroteSomething = true;
- out << name << '\t' << tax << endl;
- }else{ //this sequence contains the taxon the user wants to remove
- names.insert(name);
- }
- }else { //both have confidences so we want to make sure the users confidences are greater then or equal to the taxons
- //first remove confidences from both and see if the taxonomy exists
-
- string noNewTax = tax;
int hasConfidences = tax.find_first_of('(');
if (hasConfidences != string::npos) {
- noNewTax = removeConfidences(tax);
+ newtax = tax;
+ m->removeConfidences(newtax);
}
- int pos = noNewTax.find(noConfidenceTaxons);
+ int pos = newtax.find(noConfidenceTaxons[j]);
+
+ if (pos == string::npos) {
+ //wroteSomething = true;
+ //out << name << '\t' << tax << endl;
+ }else{ //this sequence contains the taxon the user wants to remove
+ names.insert(name);
+ remove=true; break;
+ }
- if (pos != string::npos) { //if yes, then are the confidences okay
+ }else{//if taxons has them and you don't them remove taxons
+ int hasConfidences = tax.find_first_of('(');
+ if (hasConfidences == string::npos) {
- bool remove = false;
- vector< map<string, float> > usersTaxon = getTaxons(newtax);
+ int pos = newtax.find(noConfidenceTaxons[j]);
- //the usersTaxon is most likely longer than the searchTaxons, and searchTaxon[0] may relate to userTaxon[4]
- //we want to "line them up", so we will find the the index where the searchstring starts
- int index = 0;
- for (int i = 0; i < usersTaxon.size(); i++) {
+ if (pos == string::npos) {
+ //wroteSomething = true;
+ //out << name << '\t' << tax << endl;
+ }else{ //this sequence contains the taxon the user wants to remove
+ names.insert(name);
+ remove=true; break;
+ }
+ }else { //both have confidences so we want to make sure the users confidences are greater then or equal to the taxons
+ //first remove confidences from both and see if the taxonomy exists
+
+ string noNewTax = tax;
+ int hasConfidences = tax.find_first_of('(');
+ if (hasConfidences != string::npos) {
+ noNewTax = tax;
+ m->removeConfidences(noNewTax);
+ }
+
+ int pos = noNewTax.find(noConfidenceTaxons[j]);
+
+ if (pos != string::npos) { //if yes, then are the confidences okay
- if (usersTaxon[i].begin()->first == searchTaxons[0].begin()->first) {
- index = i;
- int spot = 0;
- bool goodspot = true;
- //is this really the start, or are we dealing with a taxon of the same name?
- while ((spot < searchTaxons.size()) && ((i+spot) < usersTaxon.size())) {
- if (usersTaxon[i+spot].begin()->first != searchTaxons[spot].begin()->first) { goodspot = false; break; }
- else { spot++; }
- }
+ vector< map<string, float> > usersTaxon = getTaxons(newtax);
+
+ //the usersTaxon is most likely longer than the searchTaxons, and searchTaxon[0] may relate to userTaxon[4]
+ //we want to "line them up", so we will find the the index where the searchstring starts
+ int index = 0;
+ for (int i = 0; i < usersTaxon.size(); i++) {
- if (goodspot) { break; }
+ if (usersTaxon[i].begin()->first == searchTaxons[j][0].begin()->first) {
+ index = i;
+ int spot = 0;
+ bool goodspot = true;
+ //is this really the start, or are we dealing with a taxon of the same name?
+ while ((spot < searchTaxons[j].size()) && ((i+spot) < usersTaxon.size())) {
+ if (usersTaxon[i+spot].begin()->first != searchTaxons[j][spot].begin()->first) { goodspot = false; break; }
+ else { spot++; }
+ }
+
+ if (goodspot) { break; }
+ }
}
- }
-
- for (int i = 0; i < searchTaxons.size(); i++) {
- if ((i+index) < usersTaxon.size()) { //just in case, should never be false
- if (usersTaxon[i+index].begin()->second < searchTaxons[i].begin()->second) { //is the users cutoff less than the search taxons
+ for (int i = 0; i < searchTaxons[j].size(); i++) {
+
+ if ((i+index) < usersTaxon.size()) { //just in case, should never be false
+ if (usersTaxon[i+index].begin()->second < searchTaxons[j][i].begin()->second) { //is the users cutoff less than the search taxons
+ remove = true;
+ break;
+ }
+ }else {
remove = true;
break;
}
+ }
+
+ //passed the test so remove you
+ if (remove) {
+ names.insert(name);
+ remove=true; break;
}else {
- remove = true;
- break;
+ //wroteSomething = true;
+ //out << name << '\t' << tax << endl;
}
- }
-
- //passed the test so remove you
- if (remove) {
- names.insert(name);
}else {
- wroteSomething = true;
- out << name << '\t' << tax << endl;
+ //wroteSomething = true;
+ //out << name << '\t' << tax << endl;
}
- }else {
- wroteSomething = true;
- out << name << '\t' << tax << endl;
}
}
+
}
-
-
-
+ if (!remove) { wroteSomething = true; out << name << '\t' << tax << endl; }
m->gobble(in);
}
in.close();
exit(1);
}
}
-/**************************************************************************************************/
-string RemoveLineageCommand::removeConfidences(string tax) {
- try {
-
- string taxon = "";
- int taxLength = tax.length();
- for(int i=0;i<taxLength;i++){
- if(tax[i] == ';'){
- taxon = taxon.substr(0, taxon.find_first_of('(')); //rip off confidence
- taxon += ";";
- }
- else{
- taxon += tax[i];
- }
- }
-
- return taxon;
- }
- catch(exception& e) {
- m->errorOut(e, "RemoveLineageCommand", "removeConfidences");
- exit(1);
- }
-}
//**********************************************************************************************************************
//alignreport file has a column header line then all other lines contain 16 columns. we just want the first column since that contains the name
int RemoveLineageCommand::readAlign(){
try {
string thisOutputDir = outputDir;
if (outputDir == "") { thisOutputDir += m->hasPath(alignfile); }
- string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(alignfile)) + "pick.align.report";
+ string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(alignfile)) + getOutputFileNameTag("alignreport");
ofstream out;
m->openOutputFile(outputFileName, out);
out << endl;
while(!in.eof()){
- if (m->control_pressed) { in.close(); out.close(); remove(outputFileName.c_str()); return 0; }
+ if (m->control_pressed) { in.close(); out.close(); m->mothurRemove(outputFileName); return 0; }
in >> name; //read from first column
projects / mothur.git / blobdiff