fixed bug in read.tree updates help and validparameters strings, added ability for...

[mothur.git] / readtree.cpp

diff --git a/readtree.cpp b/readtree.cpp
index 77277e71a889171e8b248de4d7ad19c0a78babb3..d3790df170ab0651c24987bc3541b62f48197c5f 100644 (file)
--- a/readtree.cpp
+++ b/readtree.cpp
@@ -27,9 +27,10 @@ ReadTree::ReadTree() {
 /***********************************************************************/
 int ReadTree::readSpecialChar(istream& f, char c, string name) {
     try {
-               char d;
        
-               while(isspace(d=f.get()))               {;}
+               gobble(f);
+               char d = f.get();
+       
                if(d == EOF){
                        cerr << "Error: Input file ends prematurely, expecting a " << name << "\n";
                        exit(1);
@@ -39,10 +40,8 @@ int ReadTree::readSpecialChar(istream& f, char c, string name) {
                        exit(1);
                }
                if(d == ')' && f.peek() == '\n'){
-                       while(isspace(d=f.get()))               {;}
-                       f.putback(d);
+                       gobble(f);
                }       
-       
                return d;
        }
        catch(exception& e) {
@@ -58,8 +57,10 @@ int ReadTree::readSpecialChar(istream& f, char c, string name) {
 
 int ReadTree::readNodeChar(istream& f) {
        try {
-               char d;
-               while(isspace(d=f.get()))               {;}
+//             while(isspace(d=f.get()))               {;}
+               gobble(f);
+               char d = f.get();
+
                if(d == EOF){
                        cerr << "Error: Input file ends prematurely, expecting a left parenthesis\n";
                        exit(1);
@@ -86,7 +87,7 @@ float ReadTree::readBranchLength(istream& f) {
                        cerr << "Error: Missing branch length in input tree.\n";
                        exit(1);
                }
-    
+               gobble(f);
                return b;
        }
        catch(exception& e) {
@@ -99,33 +100,46 @@ float ReadTree::readBranchLength(istream& f) {
        }               
 }
 
-
 /***********************************************************************/
 /***********************************************************************/
 
-
 //Child Classes Below
 
 /***********************************************************************/
 /***********************************************************************/
 //This class reads a file in Newick form and stores it in a tree.
 
-void ReadNewickTree::read() {
+int ReadNewickTree::read() {
        try {
-               int c;
+               holder = "";
+               int c, error;
                int comment = 0;
                
                //if you are not a nexus file 
                if ((c = filehandle.peek()) != '#') {  
                        while((c = filehandle.peek()) != EOF) { 
+                               while ((c = filehandle.peek()) != EOF) {
+                                       // get past comments
+                                       if(c == '[') {
+                                               comment = 1;
+                                       }
+                                       if(c == ']'){
+                                               comment = 0;
+                                       }
+                                       if((c == '(') && (comment != 1)){ break; }
+                                       filehandle.get();
+                               }
+
                                //make new tree
                                T = new Tree(); 
                                numNodes = T->getNumNodes();
                                numLeaves = T->getNumLeaves();
                                
-                               readTreeString();  
+                               error = readTreeString(); 
+                               
                                //save trees for later commands
                                globaldata->gTree.push_back(T); 
+                               gobble(filehandle);
                        }
                //if you are a nexus file
                }else if ((c = filehandle.peek()) == '#') {
@@ -155,12 +169,15 @@ void ReadNewickTree::read() {
                                numLeaves = T->getNumLeaves();
                                
                                //read tree info
-                               readTreeString();  
+                               error = readTreeString(); 
+                                
                                //save trees for later commands
                                globaldata->gTree.push_back(T); 
                        }
                }
                
+               if (error != 0) { readOk = error; } 
+               return readOk;
        }
        catch(exception& e) {
                cout << "Standard Error: " << e.what() << " has occurred in the ReadNewickTree class Function read. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
@@ -218,7 +235,7 @@ void ReadNewickTree::nexusTranslation() {
 }
 
 /**************************************************************************************************/
-void ReadNewickTree::readTreeString() {
+int ReadNewickTree::readTreeString() {
        try {
                
                int n = 0;
@@ -230,7 +247,9 @@ void ReadNewickTree::readTreeString() {
                
                if(ch == '('){
                        n = numLeaves;  //number of leaves / sequences, we want node 1 to start where the leaves left off
+
                        lc = readNewickInt(filehandle, n, T);
+                       if (lc == -1) { cout << "error with lc" << endl; return -1; } //reports an error in reading
                
                        if(filehandle.peek()==','){                                                     
                                readSpecialChar(filehandle,',',"comma");
@@ -241,6 +260,7 @@ void ReadNewickTree::readTreeString() {
                        }                                                                                               
                        if(rooted != 1){                                                                
                                rc = readNewickInt(filehandle, n, T);
+                               if (rc == -1) { cout << "error with rc" << endl; return -1; } //reports an error in reading
                                if(filehandle.peek() == ')'){                                   
                                        readSpecialChar(filehandle,')',"right parenthesis");
                                }                                                                                       
@@ -253,23 +273,25 @@ void ReadNewickTree::readTreeString() {
                        filehandle.get(name, MAX_LINE,'\n');
                        SKIPLINE(filehandle, ch);
                
-               
                        n = T->getIndex(name);
+
                        if(n!=0){
                                cerr << "Internal error: The only taxon is not taxon 0.\n";
-                               exit(1);
+                               //exit(1);
+                               readOk = -1; return -1;
                        }
                        lc = rc = -1;
                } 
                
                while((ch=filehandle.get())!=';'){;}                                            
-                       if(rooted != 1){                                                                        
+               if(rooted != 1){                                                                        
                        T->tree[n].setChildren(lc,rc);
                        T->tree[n].setBranchLength(0);
                        T->tree[n].setParent(-1);
                        if(lc!=-1){             T->tree[lc].setParent(n);               }
                        if(rc!=-1){             T->tree[rc].setParent(n);               }
                }
+               return 0;
        
        }
        catch(exception& e) {
@@ -290,16 +312,20 @@ int ReadNewickTree::readNewickInt(istream& f, int& n, Tree* T) {
     
                if(c == '('){
                        int lc = readNewickInt(f, n, T);
+                       if (lc == -1) { return -1; } //reports an error in reading
                        readSpecialChar(f,',',"comma");
-               
-                       int rc = readNewickInt(f, n, T);                
+
+                       int rc = readNewickInt(f, n, T);
+                       if (rc == -1) { return -1; }  //reports an error in reading     
                        if(f.peek()==')'){      
-                               readSpecialChar(f,')',"right parenthesis");                                     
+                               readSpecialChar(f,')',"right parenthesis");     
                        }                       
                
                        if(f.peek() == ':'){                                                                          
-                               readSpecialChar(f,':',"colon");                                                 
-                               if(n >= numNodes){      cerr << "Error: Too many nodes in input tree\n";  exit(1); }
+                               readSpecialChar(f,':',"colon"); 
+                                                                               
+                               if(n >= numNodes){      cerr << "Error: Too many nodes in input tree\n";  readOk = -1; return -1; }
+                               
                                T->tree[n].setBranchLength(readBranchLength(f));
                        }else{T->tree[n].setBranchLength(0.0); }                                                
                
@@ -318,7 +344,7 @@ int ReadNewickTree::readNewickInt(istream& f, int& n, Tree* T) {
                        }
                
                        int blen = 0;
-                       if(d == ':')    {               blen = 1;                       }               
+                       if(d == ':')    {               blen = 1;       }               
                
                        f.putback(d);
                
@@ -328,14 +354,30 @@ int ReadNewickTree::readNewickInt(istream& f, int& n, Tree* T) {
                        //find index in tree of name
                        int n1 = T->getIndex(name);
                        
-                       if(n1 == -1){cerr << "Name: " << name << " not found\n"; exit(1);}
+                       //adds sequence names that are not in group file to the "xxx" group
+                       if(group == "not found") {
+                               cout << "Name: " << name << " is not in your groupfile, and will be disregarded. \n";  //readOk = -1; return n1;
+                               
+                               globaldata->gTreemap->namesOfSeqs.push_back(name);
+                               globaldata->gTreemap->treemap[name].groupname = "xxx";
+                               
+                               map<string, int>::iterator it;
+                               it = globaldata->gTreemap->seqsPerGroup.find("xxx");
+                               if (it == globaldata->gTreemap->seqsPerGroup.end()) { //its a new group
+                                       globaldata->gTreemap->namesOfGroups.push_back("xxx");
+                                       globaldata->gTreemap->seqsPerGroup["xxx"] = 1;
+                               }else {
+                                       globaldata->gTreemap->seqsPerGroup["xxx"]++;
+                               }
+                               
+                               group = "xxx";
+                       }
                        
-                       else T->tree[n1].setGroup(group);
-               
+                       T->tree[n1].setGroup(group);
                        T->tree[n1].setChildren(-1,-1);
                
                        if(blen == 1){  
-                               f.get();                
+                               f.get();
                                T->tree[n1].setBranchLength(readBranchLength(f));
                        }else{
                                T->tree[n1].setBranchLength(0.0);