]> git.donarmstrong.com Git - mothur.git/blob - errorchecking.cpp
Added get.line command.
[mothur.git] / errorchecking.cpp
1 /*
2  *  errorchecking.cpp
3  *  Dotur
4  *
5  *  Created by Sarah Westcott on 1/2/09.
6  *  Copyright 2009 Schloss Lab UMASS Amherst. All rights reserved.
7  *
8  */
9
10 #include "errorchecking.h"
11 #include <math.h>
12
13 /*******************************************************/
14
15 /******************************************************/
16
17 ErrorCheck::ErrorCheck() {
18         globaldata = GlobalData::getInstance();
19         validCommand = new ValidCommands();
20         validParameter = new ValidParameters();
21 }
22 /*******************************************************/
23
24 /******************************************************/
25
26 void ErrorCheck::refresh() {
27         columnfile = globaldata->getColumnFile();
28         phylipfile = globaldata->getPhylipFile();
29         listfile = globaldata->getListFile();
30         rabundfile = globaldata->getRabundFile();
31         sabundfile = globaldata->getSabundFile();
32         namefile = globaldata->getNameFile();
33         groupfile = globaldata->getGroupFile();
34         orderfile = globaldata->getOrderFile();
35         fastafile = globaldata->getFastaFile();
36         treefile = globaldata->getTreeFile();
37         cutoff = globaldata->getCutOff();
38         format = globaldata->getFormat();
39         method = globaldata->getMethod();
40
41         
42         string p[] = {
43                 "phylip",              //0
44                 "column",             //1
45                 "list",               //2
46                 "rabund",             //3
47                 "sabund",             //4
48                 "name",               //5
49                 "order",              //6
50                 "group",              //7
51                 "fasta",              //8
52                 "treefile",           //9
53                 "cutoff",             //10
54                 "precision",          //11
55                 "iters",              //12
56                 "jumble",             //13
57                 "freq",               //14
58                 "method",             //15
59                 "fileroot",           //16
60                 "line",               //17
61                 "label",              //18
62                 "single",             //19
63                 "rarefaction",        //20
64                 "shared",             //21
65                 "summary",            //22
66                 "sharedrarefaction",  //23
67                 "sharedsummary",      //24
68                 "comparegroups",      //25
69                 "abund",              //26
70                 };
71         
72         string c0[] = {p[0],p[5],p[10],p[11]};
73         string c1[] = {p[2],p[6],p[7]}; 
74         string c2[] = {p[10],p[11],p[15]}; 
75         string c3[] = {p[8]};  
76         string c4[] = {p[14],p[17],p[18],p[19],p[26]};
77         string c5[] = {p[13],p[14],p[17],p[18],p[21],p[25]};
78         string c6[] = {""}; 
79         string c7[] = {""}; 
80         string c8[] = {""}; 
81         string c9[] = {p[12],p[14],p[17],p[18],p[20],p[26]};
82         string c10[] = {p[12],p[13],p[17],p[18],p[23]};
83         string c11[] = {p[17],p[18],p[22],p[26]};   
84         string c12[] =  {p[13],p[17],p[18],p[24]}; 
85         string c13[] = {""};    
86         
87         vector<string> v0 (c0, c0+sizeof(c0)/sizeof(string)); 
88         vector<string> v1 (c1, c1+sizeof(c1)/sizeof(string));
89         vector<string> v2 (c2, c2+sizeof(c2)/sizeof(string));
90         vector<string> v3 (c3, c3+sizeof(c3)/sizeof(string));
91         vector<string> v4 (c4, c4+sizeof(c4)/sizeof(string));
92         vector<string> v5 (c5, c5+sizeof(c5)/sizeof(string));
93         vector<string> v6 (c6, c6+sizeof(c6)/sizeof(string));
94         vector<string> v7 (c7, c7+sizeof(c7)/sizeof(string));
95         vector<string> v8 (c8, c8+sizeof(c8)/sizeof(string));
96         vector<string> v9 (c9, c9+sizeof(c9)/sizeof(string));
97         vector<string> v10 (c10, c10+sizeof(c10)/sizeof(string));
98         vector<string> v11 (c11, c11+sizeof(c11)/sizeof(string));
99         vector<string> v12 (c12, c12+sizeof(c12)/sizeof(string));
100         vector<string> v13 (c13, c13+sizeof(c13)/sizeof(string));
101         
102         vector<vector<string> > allCommands;
103         allCommands.push_back(v0);
104         allCommands.push_back(v1);
105         allCommands.push_back(v2);
106         allCommands.push_back(v3);
107         allCommands.push_back(v4);
108         allCommands.push_back(v5);
109         allCommands.push_back(v6);
110         allCommands.push_back(v7);
111         allCommands.push_back(v8);
112         allCommands.push_back(v9);
113         allCommands.push_back(v10);
114         allCommands.push_back(v11);
115         allCommands.push_back(v12);
116         allCommands.push_back(v13);
117         
118         string commands[] = {
119         "read.dist",          //0
120         "read.otu",           //1
121         "cluster",            //2
122         "deconvolute",        //3
123         "collect.single",     //4
124         "collect.shared",     //5
125         "get.group",          //6
126         "get.label",          //7
127         "get.line",           //8
128         "rarefaction.single", //9
129         "rarefaction.shared", //10
130         "summary.single",     //11
131         "summary.shared",     //12
132         "quit"                //13
133         };
134         
135         for(int i = 0; i < allCommands.size(); i++)
136                 commandParameters[commands[i]] = allCommands.at(i);
137         
138          //{Lowerbound(piSent if no lowerbound), Upperbound(piSent if no upperbound), 1 if only the first 2 values, 0 if greater than, 0 if less than};
139         piSent = 3.14159;
140         double ip0[] = {10, piSent, 0, 1, 0};
141         double ip1[] = {10, piSent, 0, 1, 0};
142         double ip2[] = {0, 1, 1, 0, 0};
143         double ip3[] =  {1, piSent, 0, 0, 0};
144         double ip4[] = {1, piSent, 0, 1, 0};
145         double ip5[] = {5, piSent, 0, 1, 0};
146         
147         vector<double> ipv0 (ip0, ip0+sizeof(ip0)/sizeof(double)); 
148         vector<double> ipv1 (ip1, ip1+sizeof(ip1)/sizeof(double)); 
149         vector<double> ipv2 (ip2, ip2+sizeof(ip2)/sizeof(double)); 
150         vector<double> ipv3 (ip3, ip3+sizeof(ip3)/sizeof(double)); 
151         vector<double> ipv4 (ip4, ip4+sizeof(ip4)/sizeof(double)); 
152         vector<double> ipv5 (ip5, ip5+sizeof(ip5)/sizeof(double));
153
154         intParams[p[11]] = ipv0;
155         intParams[p[12]] = ipv1;
156         intParams[p[13]] = ipv2;
157         intParams[p[14]] = ipv3;
158         intParams[p[17]] = ipv4;
159         intParams[p[26]] = ipv5;
160         
161         randomtree = globaldata->getRandomTree();
162         sharedfile = globaldata->getSharedFile();
163 }
164
165 /*******************************************************/
166
167 /******************************************************/
168
169 ErrorCheck::~ErrorCheck() {}
170
171 /*******************************************************/
172
173 /******************************************************/
174
175 bool ErrorCheck::checkInput(string input) {
176                 errorFree = true;
177                 clear();
178                 
179                 //refresh variable
180                 refresh();
181                 
182                 //get command name and parameters
183                 int openParen = input.find_first_of('(');
184                 int closeParen = input.find_last_of(')');
185
186                 if(openParen != -1 && closeParen != -1){                        
187                         commandName = input.substr(0, openParen);   //commandName contains everything before "("
188                         optionText = input.substr(openParen+1, closeParen-openParen-1); //optionString contains everything between "(" and ")".
189                 }else if (openParen == -1) { //there is no parenthesis
190                         cout << input << " is not a valid command. You are missing the ()." << endl;
191                         return false;
192                 }
193                 
194                 //is it a valid command
195                 if (validCommand->isValidCommand(commandName) != true) { return false; }
196                 
197                 string parameter, value;
198                 
199                 //reads in parameters and values
200                 if((optionText != "") && (commandName != "help")){
201                         while((optionText.find_first_of(',') != -1) && (errorFree)) {  //while there are parameters
202                                 splitAtComma(value, optionText);
203                                 splitAtEquals(parameter, value);
204                                 
205                                 //is it a valid parameter
206                                 if (validParameter->isValidParameter(parameter) != true) { return false; }
207                                 if(!validCommandParameter(parameter,commandName)) { 
208                                         cout << "'" << parameter << "' is not a valid parameter for the " << commandName << " command.\n";
209                                         return false; 
210                                 }
211                                 if(!validParameterValue(value, parameter)) {
212                                         if(parameter.compare("precision") == 0)
213                                                 cout << "The precision parameter can only take powers of 10 as a value (e.g. 10,1000,1000, etc.)\n";
214                                         else {
215                                         vector<double> bounds = intParams[parameter];
216                                         double a = bounds.at(0);
217                                         double b = bounds.at(1);
218                                         double c = bounds.at(2);
219                                         double d = bounds.at(3);
220                                         double e = bounds.at(4);
221                                         cout << "The '" << parameter << "' parameter needs to be ";
222                                         if(c == 1)
223                                                         cout << "either '" << a << "' or '" << b << "'.\n";
224                                         else
225                                         {
226                                                 if(a != piSent)
227                                                 {
228                                                         cout << ">";
229                                                         if(d != 0)
230                                                                 cout << "=";
231                                                         cout << " '" << a << "'";
232                                                 }
233                                                 if(b == piSent)
234                                                         cout << ".\n";
235                                                 else if(a != piSent)
236                                                         cout << " and ";
237                                                 if(b != piSent)
238                                                 {
239                                                         cout << "<";
240                                                         if(e != 0)
241                                                                 cout << "=";
242                                                         cout << " '" << b << ".\n";
243                                                 }
244                                         }
245                                         }
246                                         return false;
247                                 }
248
249                                 if (parameter == "phylip" )             { phylipfile = value; }
250                                 if (parameter == "column" )             { columnfile = value; }
251                                 if (parameter == "list" )               { listfile = value; }
252                                 if (parameter == "rabund" )             { rabundfile = value; }
253                                 if (parameter == "sabund" )             { sabundfile = value; }
254                                 if (parameter == "name" )               { namefile = value; }
255                                 if (parameter == "order" )              { orderfile = value; }
256                                 if (parameter == "fasta" )              { fastafile = value; }
257                                 if (parameter == "tree" )               { treefile = value; }
258                                 if (parameter == "group" )              { groupfile = value; }
259                                 if (parameter == "shared" )             { sharedfile = value; }
260                                 if (parameter == "cutoff" )                     { cutoff = value; }
261                                 if (parameter == "precision" )          { precision = value; }
262                                 if (parameter == "iters" )                      { iters = value; }
263                                 if (parameter == "jumble" )                     { jumble = value; }
264                                 if (parameter == "freq" )                       { freq = value; }
265                                 if (parameter == "method" )                     { method = value; }
266                                 if (parameter == "fileroot" )           { fileroot = value; }
267                                 if (parameter == "line" )                       { line = value; }
268                                 if (parameter == "label" )                      { label = value; }
269                                 if (parameter == "abund" )          { abund = value; }
270                                 if (parameter == "random" )                     { randomtree = value;   }
271                         }
272                         
273                         //gets the last parameter and value
274                         if (errorFree)  { //gets the last parameter and value
275                                 value = optionText;
276                                 splitAtEquals(parameter, value);
277                                 //is it a valid parameter
278                                 if (validParameter->isValidParameter(parameter) != true) { return false; }
279                                 if(!validCommandParameter(parameter,commandName)) { 
280                                         cout << "'" << parameter << "' is not a valid parameter for the " << commandName << " command.\n";
281                                         return false; 
282                                 }
283                                 if(!validParameterValue(value, parameter)) {
284                                         if(parameter.compare("precision") == 0)
285                                                 cout << "The precision parameter can only take powers of 10 as a value (e.g. 10,1000,1000, etc.)\n";
286                                         else {
287                                         vector<double> bounds = intParams[parameter];
288                                         double a = bounds.at(0);
289                                         double b = bounds.at(1);
290                                         double c = bounds.at(2);
291                                         double d = bounds.at(3);
292                                         double e = bounds.at(4);
293                                         cout << "The '" << parameter << "' parameter needs to be ";
294                                         if(c == 1)
295                                                         cout << "either '" << a << "' or '" << b << "'.\n";
296                                         else
297                                         {
298                                                 if(a != piSent)
299                                                 {
300                                                         cout << ">";
301                                                         if(d != 0)
302                                                                 cout << "=";
303                                                         cout << " '" << a << "'";
304                                                 }
305                                                 if(b == piSent)
306                                                         cout << ".\n";
307                                                 else if(a != piSent)
308                                                         cout << " and ";
309                                                 if(b != piSent)
310                                                 {
311                                                         cout << "<";
312                                                         if(e != 0)
313                                                                 cout << "=";
314                                                         cout << " '" << b << ".\n";
315                                                 }
316                                         }
317                                         }
318                                         return false;
319                                 }
320                                 if (parameter == "phylip" )             { phylipfile = value; }
321                                 if (parameter == "column" )             { columnfile = value; }                         
322                                 if (parameter == "list" )               { listfile = value; }
323                                 if (parameter == "rabund" )             { rabundfile = value; }
324                                 if (parameter == "sabund" )             { sabundfile = value; }
325                                 if (parameter == "name" )               { namefile = value; }
326                                 if (parameter == "order" )              { orderfile = value; }
327                                 if (parameter == "group" )              { groupfile = value; }
328                                 if (parameter == "shared" )             { sharedfile = value; }
329                                 if (parameter == "fasta" )              { fastafile = value; }
330                                 if (parameter == "tree" )               { treefile = value; }
331                                 if (parameter == "cutoff" )                     { cutoff = value; }
332                                 if (parameter == "precision" )          { precision = value; }
333                                 if (parameter == "iters" )                      { iters = value; }
334                                 if (parameter == "jumble" )                     { jumble = value; }
335                                 if (parameter == "freq" )                       { freq = value; }
336                                 if (parameter == "method" )                     { method = value; }
337                                 if (parameter == "fileroot" )           { fileroot = value; }
338                                 if (parameter == "line" )                       { line = value; }
339                                 if (parameter == "label" )                      { label = value; }
340                                 if (parameter == "random" )                     { randomtree = value;   }
341                                 if (parameter == "abund" )          { abund = value; }
342                         }
343                 }
344                 
345                 //make sure the user does not use both the line and label parameters
346                 if ((line != "") && (label != "")) { cout << "You may use either the line or label parameters, but not both." << endl; return false; }
347                 
348                 if (commandName == "read.dist") { 
349                         validateReadFiles();
350                         validateReadDist();
351                 }else if (commandName == "read.otu") { 
352                         //you want to do shared commands
353                         if ((listfile != "") && (groupfile != ""))      {
354                                 validateParseFiles(); //checks the listfile and groupfile parameters
355                         }else { //you want to do single commands
356                                 validateReadFiles();
357                                 validateReadPhil();
358                         }
359                 }else if (commandName == "read.shared") { 
360                         //you want to do shared commands with just the shared file
361                         validateReadFiles();
362                 }else if (commandName == "read.tree") { 
363                         validateTreeFiles(); //checks the treefile and groupfile parameters
364                 }else if (commandName == "deconvolute") {
365                         if (fastafile == "") { cout << "You must enter a fastafile with the deconvolute() command." << endl; return false; }
366                         validateReadFiles();
367                 }
368                 
369                 //are you trying to cluster before you have read something                      
370                 if ((commandName == "cluster") && (globaldata->getSparseMatrix() == NULL) ||
371                         (commandName == "cluster") && (globaldata->getListVector() == NULL)) {
372                                 cout << "Before you use the cluster command, you first need to read in a distance matrix." << endl; 
373                                 errorFree = false;
374                 } 
375                 
376                 if (commandName == "parsimony") {
377                         //are you trying to use parsimony without reading a tree or saying you want random distribution
378                         if (randomtree == "")  {
379                                 if (globaldata->gTree.size() == 0) {
380                                         cout << "You must read a treefile and a groupfile or set the randomtree parameter to the output filename you wish, before you may execute the parsimony command." << endl; return false;  }
381                         }
382                 }
383                 
384                 if ((commandName == "unifrac.weighted") || (commandName == "unifrac.unweighted")) {
385                         if (globaldata->gTree.size() == 0) {//no trees were read
386                                 cout << "You must execute the read.tree command, before you may execute the unifrac.weighted or unifrac.unweighted command." << endl; return false;  }
387                 }
388                 
389                 //check for valid method
390                 if(commandName == "get.group") {
391                         if ((globaldata->getGroupFile() == "")) { cout << "You must read a group before you can use the get.group command." << endl; return false; }
392                 }
393                 if (commandName == "get.label" || commandName == "get.line") {
394                         if ((globaldata->getListFile() == "") && (globaldata->getRabundFile() == "") && (globaldata->getSabundFile() == "")) { cout << "You must read a list, sabund or rabund before you can use the get.label or get.line command." << endl; return false; }
395                 }
396                 if (commandName == "cluster") {
397                         if ((method == "furthest") || (method == "nearest") || (method == "average")) { }
398                         else {cout << "Not a valid clustering method.  Valid clustering algorithms are furthest, nearest or average." << endl; return false; }
399                 }
400                 
401                 if ((commandName == "collect.single") || (commandName == "rarefaction.single") || (commandName == "summary.single") ){ 
402                         if ((globaldata->getListFile() == "") && (globaldata->getRabundFile() == "") && (globaldata->getSabundFile() == "")) { cout << "You must read a list, sabund or rabund before you can use the collect.single, rarefaction.single or summary.single commands." << endl; return false; }
403                 }
404                 
405                 if ((commandName == "collect.shared") || (commandName == "rarefaction.shared") || (commandName == "summary.shared") ){ 
406                         if (globaldata->getSharedFile() == "") {
407                                 if (globaldata->getListFile() == "") { cout << "You must read a list and a group, or a shared before you can use the collect.shared, rarefaction.shared or summary.shared commands." << endl; return false; }
408                                 else if (globaldata->getGroupFile() == "") { cout << "You must read a list and a group, or a shared before you can use the collect.shared, rarefaction.shared or summary.shared commands." << endl; return false; }
409                         }
410                 }
411
412                 globaldata->clearAbund();
413
414                 return errorFree;
415 }
416
417 /*******************************************************/
418
419 /******************************************************/
420 //This function checks to make sure the user entered a file to 
421 // read and that the file exists and can be opened.
422 void ErrorCheck::validateReadFiles() {
423         try {
424                 //Validating files for read
425                 ifstream filehandle;
426                 int ableToOpen;
427         
428                 //are we reading a phylipfile
429                 if (phylipfile != "") {
430                         ableToOpen = openInputFile(phylipfile, filehandle);
431                         filehandle.close();
432                         //unable to open
433                         if (ableToOpen == 1) { errorFree = false; }
434                         else { globaldata->inputFileName = phylipfile; }
435                 //are we reading a phylipfile
436                 }else if (columnfile != "") {
437                         ableToOpen = openInputFile(columnfile, filehandle);
438                         filehandle.close();
439                         //unable to open
440                         if (ableToOpen == 1) { errorFree = false; }
441                         else { globaldata->inputFileName = columnfile; }
442                 //are we reading a listfile
443                 }else if (listfile!= "") {
444                         ableToOpen = openInputFile(listfile, filehandle);
445                         filehandle.close();
446                         //unable to open
447                         if (ableToOpen == 1) {  errorFree = false; }
448                         else { globaldata->inputFileName = listfile; }
449                 //are we reading a rabundfile
450                 }else if (rabundfile != "") {
451                         ableToOpen = openInputFile(rabundfile, filehandle);
452                         filehandle.close();
453                         //unable to open
454                         if (ableToOpen == 1) {  errorFree = false; }
455                         else { globaldata->inputFileName = rabundfile; }
456                 //are we reading a sabundfile
457                 }else if (sabundfile != "") {
458                         ableToOpen = openInputFile(sabundfile, filehandle);
459                         filehandle.close();
460                         //unable to open
461                         if (ableToOpen == 1) {  errorFree = false; }
462                         else { globaldata->inputFileName = sabundfile; }
463                 }else if (fastafile != "") {
464                         ableToOpen = openInputFile(fastafile, filehandle);
465                         filehandle.close();
466                         //unable to open
467                         if (ableToOpen == 1) {  errorFree = false; }
468                         else { globaldata->inputFileName = fastafile; }
469                 }else if (sharedfile != "") {
470                         ableToOpen = openInputFile(sharedfile, filehandle);
471                         filehandle.close();
472                         //unable to open
473                         if (ableToOpen == 1) {  errorFree = false; }
474                         else { globaldata->inputFileName = sharedfile; }
475                 }else{ //no file given
476                         errorFree = false;
477                 }
478         }
479         catch(exception& e) {
480                 cout << "Standard Error: " << e.what() << " has occurred in the ErrorCheck class Function validateReadFiles. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
481                 exit(1);
482         }
483         catch(...) {
484                 cout << "An unknown error has occurred in the ErrorCheck class function validateReadFiles. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
485                 exit(1);
486         }
487         
488 }
489 /*******************************************************/
490
491 /******************************************************/
492 //This function checks to see if the given paramter
493 //is a valid paramter for the given command.
494 bool ErrorCheck::validCommandParameter(string parameter, string commandName) {
495         try {
496                 for(int i = 0; i < commandParameters[commandName].size(); i++)
497                         if(parameter.compare(commandParameters[commandName][i]) == 0)
498                                 return true;
499                 return false;
500         }
501                 
502         catch(exception& e) {
503                 cout << "Standard Error: " << e.what() << " has occurred in the ErrorCheck class Function validateReadFiles. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
504                 exit(1);
505         }
506         catch(...) {
507                 cout << "An unknown error has occurred in the ErrorCheck class function validateReadFiles. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
508                 exit(1);
509         }
510 }
511 /*******************************************************/
512
513 /******************************************************/
514 //This function checks to see if the given paramter value
515 //is convertable into an int if that parameter requires it.
516 bool ErrorCheck::validParameterValue(string value, string parameter) {
517         try {
518                 int pVal;
519                 if(intParams.count(parameter) == 1)
520                 {
521                         vector<double> bounds = intParams[parameter];
522                         bool valid = convertTest(value, pVal);
523                         if(!valid)
524                                 return false;
525                         if(parameter.compare("precision") == 0)
526                         {
527                                 double logNum = log10((double)pVal);
528                                 double diff = (double)((int)logNum - logNum);
529                                 if(diff != 0)
530                                         return false;
531                         }
532                         double a = bounds.at(0);
533                         double b = bounds.at(1);
534                         double c = bounds.at(2);
535                         double d = bounds.at(3);
536                         double e = bounds.at(4);
537                         bool a0 = pVal > a;
538                         bool a1 = pVal >= a;
539                         bool b0 = pVal < b;
540                         bool b1 = pVal <= b;
541                         
542                         if(c != 1)
543                         {
544                                 if(a == piSent && b == piSent)
545                                         return true;
546                                 if(a != piSent && b == piSent)
547                                 {
548                                         if(d == 0)
549                                                 return a0;
550                                         else
551                                                 return a1;
552                                 }
553                                 else if(a == piSent && b != piSent)
554                                 {
555                                         if(e == 0)
556                                                 return b0;
557                                         else
558                                                 return b1;
559                                 }
560                                 else
561                                 {
562                                         if(d == 0 && e == 0)
563                                                 return (a0 && b0);
564                                         else if(d == 0 && e == 1)
565                                                 return (a0 && b1);
566                                         else if(d == 1 && e == 0)
567                                                 return (a1 && b0);
568                                         else
569                                                 return (a1 && b1);
570                                 }
571                         }
572                         else
573                         {
574                                 if(a == piSent && b == piSent)
575                                         return true;
576                                 if(a != piSent && b == piSent)
577                                         return (pVal == a);
578                                 else if(a == piSent && b != piSent)
579                                         return (pVal == b);
580                                 else
581                                         return (pVal == a || pVal == b);
582                         }
583                 }
584                 return true;
585         }
586                 
587         catch(exception& e) {
588                 cout << "Standard Error: " << e.what() << " has occurred in the ErrorCheck class Function validateReadFiles. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
589                 exit(1);
590         }
591         catch(...) {
592                 cout << "An unknown error has occurred in the ErrorCheck class function validateReadFiles. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
593                 exit(1);
594         }
595 }               
596 /*******************************************************/
597
598 /******************************************************/
599 //This function checks to make sure the user entered appropriate
600 // format parameters on a distfile read
601 void ErrorCheck::validateReadDist() {
602         try {
603                 ifstream filehandle;
604                 int ableToOpen;
605                 
606                 if ((phylipfile == "") && (columnfile == "")) { cout << "When executing a read.dist you must enter a phylip or a column." << endl; errorFree = false; }
607                 else if ((phylipfile != "") && (columnfile != "")) { cout << "When executing a read.dist you must enter ONLY ONE of the following: phylip or column." << endl; errorFree = false; }
608                 
609                 if (columnfile != "") {
610                         if (namefile == "") {
611                                 cout << "You need to provide a namefile if you are going to use the column format." << endl;
612                                 errorFree = false; 
613                         }else {
614                                 ableToOpen = openInputFile(namefile, filehandle);
615                                 filehandle.close();
616                                 //unable to open
617                                 if (ableToOpen == 1) { errorFree = false; }
618                         }
619                 }
620         }
621         catch(exception& e) {
622                 cout << "Standard Error: " << e.what() << " has occurred in the ErrorCheck class Function validateReadDist. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
623                 exit(1);
624         }
625         catch(...) {
626                 cout << "An unknown error has occurred in the ErrorCheck class function validateReadDist. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
627                 exit(1);
628         }
629 }
630 /*******************************************************/
631
632 /******************************************************/
633 //This function checks to make sure the user entered appropriate
634 // format parameters on a parselistcommand
635 void ErrorCheck::validateParseFiles() {
636         try {
637                 ifstream filehandle;
638                 int ableToOpen;
639                 
640                 //checks for valid files
641         
642                 if (listfile == "") { cout << "When executing a read.otu for groups you must enter a list and a group." << endl; errorFree = false; }
643                 else if (groupfile == "") { cout << "When executing a read.otu for groups you must enter a list and a group." << endl; errorFree = false; }
644         
645                 //checks parameters on the read command
646                 if (listfile != "") {
647                         ableToOpen = openInputFile(listfile, filehandle);
648                         filehandle.close();
649                         if (ableToOpen == 1) { //unable to open
650                                 errorFree = false;
651                         }
652                         if (groupfile != "") {
653                                 ableToOpen = openInputFile(groupfile, filehandle);
654                                 filehandle.close();
655                                 if (ableToOpen == 1) { //unable to open
656                                         errorFree = false;;
657                                 }
658                         }
659                 }
660         }
661         catch(exception& e) {
662                 cout << "Standard Error: " << e.what() << " has occurred in the ErrorCheck class Function validateReadPhil. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
663                 exit(1);
664         }
665         catch(...) {
666                 cout << "An unknown error has occurred in the ErrorCheck class function validateReadPhil. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
667                 exit(1);
668         }
669 }
670 /*******************************************************/
671
672 /******************************************************/
673 //This function checks to make sure the user entered appropriate
674 // format parameters on a parselistcommand
675 void ErrorCheck::validateTreeFiles() {
676         try {
677                 ifstream filehandle;
678                 int ableToOpen;
679                 
680                 //checks for valid files
681         
682                 if (treefile == "") { cout << "When executing a read.tree you must enter a treefile and a groupfile." << endl; errorFree = false; }
683                 else if (groupfile == "") { cout << "When executing a read.tree you must enter a treefile and a groupfile." << endl; errorFree = false; }
684         
685                 //checks parameters on the read command
686                 if (treefile != "") {
687                         ableToOpen = openInputFile(treefile, filehandle);
688                         filehandle.close();
689                         if (ableToOpen == 1) { //unable to open
690                                 errorFree = false;
691                         }
692                         if (groupfile != "") {
693                                 ableToOpen = openInputFile(groupfile, filehandle);
694                                 filehandle.close();
695                                 if (ableToOpen == 1) { //unable to open
696                                         errorFree = false;;
697                                 }
698                         }
699                 }
700         }
701         catch(exception& e) {
702                 cout << "Standard Error: " << e.what() << " has occurred in the ErrorCheck class Function validateTreeFiles. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
703                 exit(1);
704         }
705         catch(...) {
706                 cout << "An unknown error has occurred in the ErrorCheck class function validateTreeFiles. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
707                 exit(1);
708         }
709 }
710
711 /*******************************************************/
712
713 /******************************************************/
714 //This function checks to make sure the user entered appropriate
715 // format parameters on a distfile read
716 void ErrorCheck::validateReadPhil() {
717         try {
718                 ifstream filehandle;
719                 int ableToOpen;
720                 
721                 //checks to make sure only one file type is given
722                 if (listfile != "") { 
723                         if ((rabundfile != "") || (sabundfile != "")) { 
724                                 cout << "When executing a read.otu you must enter ONLY ONE of the following: list, rabund or sabund." << endl; errorFree = false; }
725                 }else if (rabundfile != "") { 
726                         if ((listfile != "") || (sabundfile != "")) { 
727                                 cout << "When executing a read.otu you must enter ONLY ONE of the following: list, rabund or sabund." << endl; errorFree = false; }
728                 }else if (sabundfile != "") { 
729                         if ((listfile != "") || (rabundfile != "")) { 
730                                 cout << "When executing a read.otu you must enter ONLY ONE of the following: list, rabund or sabund." << endl; errorFree = false; }
731                 }else if ((listfile == "") && (rabundfile == "") && (sabundfile == "")) {
732                             cout << "When executing a read.otu you must enter one of the following: list, rabund or sabund." << endl; errorFree = false; 
733                 }
734                 
735                 //checks parameters on the read command
736                 if (orderfile != "") {
737                         ableToOpen = openInputFile(orderfile, filehandle);
738                         filehandle.close();
739                         if (ableToOpen == 1) { //unable to open
740                                 errorFree = false;
741                         }
742                 }       
743         }
744         catch(exception& e) {
745                 cout << "Standard Error: " << e.what() << " has occurred in the ErrorCheck class Function validateReadPhil. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
746                 exit(1);
747         }
748         catch(...) {
749                 cout << "An unknown error has occurred in the ErrorCheck class function validateReadPhil. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
750                 exit(1);
751         }
752 }
753 /*******************************************************/
754
755 /******************************************************/
756
757 void ErrorCheck::clear() {
758         //option definitions should go here...
759         phylipfile              =       "";
760         columnfile              =       "";
761         listfile                =       "";
762         rabundfile              =       "";
763         sabundfile              =       "";
764         namefile                =       "";
765         groupfile               =       ""; 
766         orderfile               =       "";
767         sharedfile              =       "";
768         line                    =       "";
769         label                   =       "";
770         method                  =   "furthest";
771 }
772 /*******************************************************/
773
774 /******************************************************/
775