fixed get.lienage and remove.lineage bug with confidence scores that are floats....

[mothur.git] / getlineagecommand.cpp

diff --git a/getlineagecommand.cpp b/getlineagecommand.cpp
index 4231435e556f205b753985bacca8d418b0d07c2c..2a5505f149241c88b0591f1622a50d6a2fc89577 100644 (file)
--- a/getlineagecommand.cpp
+++ b/getlineagecommand.cpp
@@ -27,8 +27,7 @@ vector<string> GetLineageCommand::getValidParameters(){
 //**********************************************************************************************************************
 GetLineageCommand::GetLineageCommand(){        
        try {
-               abort = true;
-               //initialize outputTypes
+               abort = true; calledHelp = true; 
                vector<string> tempOutNames;
                outputTypes["fasta"] = tempOutNames;
                outputTypes["taxonomy"] = tempOutNames;
@@ -68,10 +67,10 @@ vector<string> GetLineageCommand::getRequiredFiles(){
 //**********************************************************************************************************************
 GetLineageCommand::GetLineageCommand(string option)  {
        try {
-               abort = false;
+               abort = false; calledHelp = false;   
                                
                //allow user to run help
-               if(option == "help") { help(); abort = true; }
+               if(option == "help") { help(); abort = true; calledHelp = true; }
                
                else {
                        //valid paramters for this command
@@ -238,7 +237,7 @@ void GetLineageCommand::help(){
 int GetLineageCommand::execute(){
        try {
                
-               if (abort == true) { return 0; }
+               if (abort == true) { if (calledHelp) { return 0; }  return 2;   }
                
                if (m->control_pressed) { return 0; }
                
@@ -258,6 +257,33 @@ int GetLineageCommand::execute(){
                        m->mothurOut("Output File Names: "); m->mothurOutEndLine();
                        for (int i = 0; i < outputNames.size(); i++) {  m->mothurOut(outputNames[i]); m->mothurOutEndLine();    }
                        m->mothurOutEndLine();
+                       
+                       //set fasta file as new current fastafile
+                       string current = "";
+                       itTypes = outputTypes.find("fasta");
+                       if (itTypes != outputTypes.end()) {
+                               if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setFastaFile(current); }
+                       }
+                       
+                       itTypes = outputTypes.find("name");
+                       if (itTypes != outputTypes.end()) {
+                               if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setNameFile(current); }
+                       }
+                       
+                       itTypes = outputTypes.find("group");
+                       if (itTypes != outputTypes.end()) {
+                               if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setGroupFile(current); }
+                       }
+                       
+                       itTypes = outputTypes.find("list");
+                       if (itTypes != outputTypes.end()) {
+                               if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setListFile(current); }
+                       }
+                       
+                       itTypes = outputTypes.find("taxonomy");
+                       if (itTypes != outputTypes.end()) {
+                               if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setTaxonomyFile(current); }
+                       }                       
                }
                
                return 0;               
@@ -545,7 +571,7 @@ int GetLineageCommand::readTax(){
                //bool wroteSomething = false;
                
                bool taxonsHasConfidence = false;
-               vector< map<string, int> > searchTaxons;
+               vector< map<string, float> > searchTaxons;
                string noConfidenceTaxons = taxons;
                int hasConPos = taxons.find_first_of('(');
                if (hasConPos != string::npos) {  
@@ -603,7 +629,7 @@ int GetLineageCommand::readTax(){
                                        if (pos != string::npos) { //if yes, then are the confidences okay
                                                
                                                bool good = true;
-                                               vector< map<string, int> > usersTaxon = getTaxons(newtax);
+                                               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
@@ -665,10 +691,10 @@ int GetLineageCommand::readTax(){
        }
 }
 /**************************************************************************************************/
-vector< map<string, int> > GetLineageCommand::getTaxons(string tax) {
+vector< map<string, float> > GetLineageCommand::getTaxons(string tax) {
        try {
                
-               vector< map<string, int> > t;
+               vector< map<string, float> > t;
                string taxon = "";
                int taxLength = tax.length();
                for(int i=0;i<taxLength;i++){
@@ -677,12 +703,18 @@ vector< map<string, int> > GetLineageCommand::getTaxons(string tax) {
                                int openParen = taxon.find_first_of('(');
                                int closeParen = taxon.find_last_of(')');
                                
-                               string newtaxon = taxon.substr(0, openParen); //rip off confidence
-                               string confidence = taxon.substr((openParen+1), (closeParen-openParen-1));  
-                               int con = 0;
+                               string newtaxon, confidence;
+                               if ((openParen != string::npos) && (closeParen != string::npos)) {
+                                       newtaxon = taxon.substr(0, openParen); //rip off confidence
+                                       confidence = taxon.substr((openParen+1), (closeParen-openParen-1));  
+                               }else{
+                                       newtaxon = taxon;
+                                       confidence = "0";
+                               } 
+                               float con = 0;
                                convert(confidence, con);
                                
-                               map<string, int> temp;
+                               map<string, float> temp;
                                temp[newtaxon] = con;
                                t.push_back(temp);