]> git.donarmstrong.com Git - mothur.git/blob - commandfactory.cpp
added cluster.classic command
[mothur.git] / commandfactory.cpp
1 /*
2  *  commandfactory.cpp
3  *  
4  *
5  *  Created by Pat Schloss on 10/25/08.
6  *  Copyright 2008 Patrick D. Schloss. All rights reserved.
7  *
8  */
9
10 #include "command.hpp"
11 #include "readdistcommand.h"
12 #include "readtreecommand.h"
13 #include "readotucommand.h"
14 #include "clustercommand.h"
15 #include "collectcommand.h"
16 #include "collectsharedcommand.h"
17 #include "getgroupcommand.h"
18 #include "getlabelcommand.h"
19 #include "rarefactcommand.h"
20 #include "summarycommand.h"
21 #include "summarysharedcommand.h"
22 #include "rarefactsharedcommand.h"
23 #include "quitcommand.h"
24 #include "helpcommand.h"
25 #include "commandfactory.hpp"
26 #include "deconvolutecommand.h"
27 #include "parsimonycommand.h"
28 #include "unifracunweightedcommand.h"
29 #include "unifracweightedcommand.h"
30 #include "libshuffcommand.h"
31 #include "heatmapcommand.h"
32 #include "heatmapsimcommand.h"
33 #include "filterseqscommand.h"
34 #include "venncommand.h"
35 #include "nocommands.h"
36 #include "binsequencecommand.h"
37 #include "getoturepcommand.h"
38 #include "treegroupscommand.h"
39 #include "bootstrapsharedcommand.h"
40 //#include "consensuscommand.h"
41 #include "distancecommand.h"
42 #include "aligncommand.h"
43 #include "matrixoutputcommand.h"
44 #include "getsabundcommand.h"
45 #include "getrabundcommand.h"
46 #include "seqsummarycommand.h"
47 #include "screenseqscommand.h"
48 #include "reversecommand.h"
49 #include "trimseqscommand.h"
50 #include "mergefilecommand.h"
51 #include "chimeraseqscommand.h"
52 #include "listseqscommand.h"
53 #include "getseqscommand.h"
54 #include "removeseqscommand.h"
55 #include "systemcommand.h"
56 #include "secondarystructurecommand.h"
57 #include "getsharedotucommand.h"
58 #include "getlistcountcommand.h"
59 #include "hclustercommand.h"
60 #include "classifyseqscommand.h"
61 #include "phylotypecommand.h"
62 #include "mgclustercommand.h"
63 #include "preclustercommand.h"
64 #include "pcacommand.h"
65 #include "otuhierarchycommand.h"
66 #include "setdircommand.h"
67 #include "parselistscommand.h"
68 #include "parsesffcommand.h"
69 #include "chimeraccodecommand.h"
70 #include "chimeracheckcommand.h"
71 #include "chimeraslayercommand.h"
72 #include "chimerapintailcommand.h"
73 #include "chimerabellerophoncommand.h"
74 #include "setlogfilecommand.h"
75 #include "phylodiversitycommand.h"
76 #include "makegroupcommand.h"
77 #include "chopseqscommand.h"
78 #include "clearcutcommand.h"
79 #include "catchallcommand.h"
80 #include "splitabundcommand.h"
81 #include "clustersplitcommand.h"
82 #include "classifyotucommand.h"
83 #include "degapseqscommand.h"
84 #include "getrelabundcommand.h"
85 #include "sensspeccommand.h"
86 #include "sffinfocommand.h"
87 #include "seqerrorcommand.h"
88 #include "normalizesharedcommand.h"
89 #include "metastatscommand.h"
90 #include "splitgroupscommand.h"
91 #include "clusterfragmentscommand.h"
92 #include "getlineagecommand.h"
93 #include "removelineagecommand.h"
94 #include "parsefastaqcommand.h"
95 #include "pipelinepdscommand.h"
96 #include "deuniqueseqscommand.h"
97 #include "pairwiseseqscommand.h"
98 #include "clusterdoturcommand.h"
99
100
101 /*******************************************************/
102
103 /******************************************************/
104 CommandFactory* CommandFactory::getInstance() {
105         if( _uniqueInstance == 0) {
106                 _uniqueInstance = new CommandFactory();
107         }
108         return _uniqueInstance;
109 }
110 /***********************************************************/
111
112 /***********************************************************/
113 //note: This class is resposible for knowing which commands are mpiEnabled,
114 //If a command is not enabled only process 0 will execute the command. 
115 //This avoids redundant outputs on pieces of code we have not paralellized. 
116 //If you add mpi code to a existing command you need to modify the list below or the code will hang on MPI blocking commands like FIle_open. 
117 //example:  commands["dist.seqs"] = "MPIEnabled";
118
119 CommandFactory::CommandFactory(){
120         string s = "";
121         m = MothurOut::getInstance();
122         
123         command = new NoCommand(s);
124         shellcommand = new NoCommand(s);
125         pipecommand = new NoCommand(s);
126         
127         outputDir = ""; inputDir = "";
128         logFileName = "";
129         append = false;
130         
131         //initialize list of valid commands
132         commands["read.dist"]                   = "read.dist"; 
133         commands["read.otu"]                    = "read.otu";
134         commands["read.tree"]                   = "read.tree"; 
135         commands["bin.seqs"]                    = "bin.seqs"; 
136         commands["get.oturep"]                  = "get.oturep";
137         commands["cluster"]                             = "cluster"; 
138         commands["unique.seqs"]                 = "unique.seqs"; 
139         commands["dist.shared"]                 = "dist.shared";
140         commands["collect.single"]              = "collect.single"; 
141         commands["collect.shared"]              = "collect.shared"; 
142         commands["rarefaction.single"]  = "rarefaction.single"; 
143         commands["rarefaction.shared"]  = "rarefaction.shared"; 
144         commands["summary.single"]              = "summary.single"; 
145         commands["summary.shared"]              = "summary.shared"; 
146         commands["parsimony"]                   = "parsimony";
147         commands["unifrac.weighted"]    = "unifrac.weighted"; 
148         commands["unifrac.unweighted"]  = "unifrac.unweighted"; 
149         commands["libshuff"]                    = "libshuff";
150         commands["tree.shared"]                 = "tree.shared";
151         commands["heatmap.bin"]                 = "heatmap.bin";
152         commands["heatmap.sim"]                 = "heatmap.sim";
153         commands["venn"]                                = "venn";
154         commands["get.group"]           = "get.group";
155         commands["get.label"]           = "get.label";
156         commands["get.sabund"]          = "get.sabund";
157         commands["get.rabund"]          = "get.rabund";
158         commands["bootstrap.shared"]    = "bootstrap.shared";
159         //commands["consensus"]                 = "consensus";
160         commands["help"]                                = "help";
161         commands["reverse.seqs"]                = "reverse.seqs";
162         commands["trim.seqs"]                   = "trim.seqs";
163         commands["list.seqs"]                   = "list.seqs";
164         commands["get.seqs"]                    = "get.seqs";
165         commands["remove.seqs"]                 = "get.seqs";
166         commands["system"]                              = "system";
167         commands["align.check"]                 = "align.check";
168         commands["get.sharedseqs"]              = "get.sharedseqs";
169         commands["get.otulist"]                 = "get.otulist";
170         commands["hcluster"]                    = "hcluster"; 
171         commands["phylotype"]                   = "phylotype";
172         commands["mgcluster"]                   = "mgcluster";
173         commands["pre.cluster"]                 = "pre.cluster";
174         commands["pcoa"]                                = "pcoa";
175         commands["otu.hierarchy"]               = "otu.hierarchy";
176         commands["set.dir"]                             = "set.dir";
177         commands["merge.files"]                 = "merge.files";
178         commands["parse.list"]                  = "parse.list";
179         commands["parse.sff"]                   = "parse.sff";
180         commands["set.logfile"]                 = "set.logfile";
181         commands["phylo.diversity"]             = "phylo.diversity";
182         commands["make.group"]                  = "make.group";
183         commands["chop.seqs"]                   = "chop.seqs";
184         commands["clearcut"]                    = "clearcut";
185         commands["catchall"]                    = "catchall";
186         commands["split.abund"]                 = "split.abund";
187         commands["classify.otu"]                = "classify.otu";
188         commands["degap.seqs"]                  = "degap.seqs";
189         commands["get.relabund"]                = "get.relabund";
190         commands["sffinfo"]                             = "sffinfo";
191         commands["normalize.shared"]    = "normalize.shared";
192         commands["metastats"]                   = "metastats";
193         commands["split.groups"]                = "split.groups";
194         commands["cluster.fragments"]   = "cluster.fragments";
195         commands["get.lineage"]                 = "get.lineage";
196         commands["remove.lineage"]              = "remove.lineage";
197         commands["fastq.info"]                  = "fastq.info";
198         commands["deunique.seqs"]               = "deunique.seqs";
199         commands["cluster.classic"]             = "cluster.classic";
200         commands["pairwise.seqs"]               = "MPIEnabled";
201         commands["pipeline.pds"]                = "MPIEnabled";
202         commands["classify.seqs"]               = "MPIEnabled"; 
203         commands["dist.seqs"]                   = "MPIEnabled";
204         commands["filter.seqs"]                 = "MPIEnabled";
205         commands["align.seqs"]                  = "MPIEnabled";
206         commands["chimera.seqs"]                = "chimera.seqs";
207         commands["chimera.ccode"]               = "MPIEnabled";
208         commands["chimera.check"]               = "MPIEnabled";
209         commands["chimera.slayer"]              = "MPIEnabled";
210         commands["chimera.pintail"]             = "MPIEnabled";
211         commands["chimera.bellerophon"] = "MPIEnabled";
212         commands["screen.seqs"]                 = "MPIEnabled";
213         commands["summary.seqs"]                = "MPIEnabled";
214         commands["cluster.split"]               = "MPIEnabled";
215         commands["sens.spec"]                   = "sens.spec";
216         commands["seq.error"]                   = "seq.error";
217         commands["quit"]                                = "MPIEnabled"; 
218
219 }
220 /***********************************************************/
221
222 /***********************************************************/
223 bool CommandFactory::MPIEnabled(string commandName) {
224         bool mpi = false;
225         it = commands.find(commandName);
226         if (it != commands.end()) { 
227                 if (it->second == "MPIEnabled") { return true; }
228         }
229         return mpi;
230 }
231 /***********************************************************/
232
233 /***********************************************************/
234 CommandFactory::~CommandFactory(){
235         _uniqueInstance = 0;
236         delete command;
237         delete shellcommand;
238         delete pipecommand;
239 }
240
241 /***********************************************************/
242
243 /***********************************************************/
244 //This function calls the appropriate command fucntions based on user input.
245 Command* CommandFactory::getCommand(string commandName, string optionString){
246         try {
247                 delete command;   //delete the old command
248                 
249                 //user has opted to redirect output from dir where input files are located to some other place
250                 if (outputDir != "") { 
251                         if (optionString != "") { optionString += ", outputdir=" + outputDir; }
252                         else { optionString += "outputdir=" + outputDir; }
253                 }
254                 
255                 //user has opted to redirect input from dir where mothur.exe is located to some other place
256                 if (inputDir != "") { 
257                         if (optionString != "") { optionString += ", inputdir=" + inputDir; }
258                         else { optionString += "inputdir=" + inputDir; }
259                 }
260                 
261                 if(commandName == "read.dist")                                  {       command = new ReadDistCommand(optionString);                            }
262                 else if(commandName == "read.otu")                              {       command = new ReadOtuCommand(optionString);                                     }
263                 else if(commandName == "read.tree")                             {       command = new ReadTreeCommand(optionString);                            }
264                 else if(commandName == "cluster")                               {       command = new ClusterCommand(optionString);                                     }
265                 else if(commandName == "unique.seqs")                   {       command = new DeconvoluteCommand(optionString);                         }
266                 else if(commandName == "parsimony")                             {       command = new ParsimonyCommand(optionString);                           }
267                 else if(commandName == "help")                                  {       command = new HelpCommand(optionString);                                        }
268                 else if(commandName == "quit")                                  {       command = new QuitCommand(optionString);                                        }
269                 else if(commandName == "collect.single")                {       command = new CollectCommand(optionString);                                     }
270                 else if(commandName == "collect.shared")                {       command = new CollectSharedCommand(optionString);                       }
271                 else if(commandName == "rarefaction.single")    {       command = new RareFactCommand(optionString);                            }
272                 else if(commandName == "rarefaction.shared")    {       command = new RareFactSharedCommand(optionString);                      }
273                 else if(commandName == "summary.single")                {       command = new SummaryCommand(optionString);                                     }
274                 else if(commandName == "summary.shared")                {       command = new SummarySharedCommand(optionString);                       }
275                 else if(commandName == "unifrac.weighted")              {       command = new UnifracWeightedCommand(optionString);                     }
276                 else if(commandName == "unifrac.unweighted")    {       command = new UnifracUnweightedCommand(optionString);           }
277                 else if(commandName == "get.group")             {   command = new GetgroupCommand(optionString);                                }
278                 else if(commandName == "get.label")             {   command = new GetlabelCommand(optionString);                                }
279                 else if(commandName == "get.sabund")            {   command = new GetSAbundCommand(optionString);                               }
280                 else if(commandName == "get.rabund")            {   command = new GetRAbundCommand(optionString);                               }
281                 else if(commandName == "libshuff")              {   command = new LibShuffCommand(optionString);                                }
282                 else if(commandName == "heatmap.bin")                   {   command = new HeatMapCommand(optionString);                                 }
283                 else if(commandName == "heatmap.sim")                   {   command = new HeatMapSimCommand(optionString);                              }
284                 else if(commandName == "filter.seqs")                   {   command = new FilterSeqsCommand(optionString);                              }
285                 else if(commandName == "venn")                                  {   command = new VennCommand(optionString);                                    }
286                 else if(commandName == "bin.seqs")                              {   command = new BinSeqCommand(optionString);                                  }
287                 else if(commandName == "get.oturep")                    {   command = new GetOTURepCommand(optionString);                               }
288                 else if(commandName == "tree.shared")                   {   command = new TreeGroupCommand(optionString);                               }
289                 else if(commandName == "dist.shared")                   {   command = new MatrixOutputCommand(optionString);                    }
290                 else if(commandName == "bootstrap.shared")              {   command = new BootSharedCommand(optionString);                              }
291                 else if(commandName == "consensus")                             {   command = new ConcensusCommand(optionString);                               }
292                 else if(commandName == "dist.seqs")                             {   command = new DistanceCommand(optionString);                                }
293                 else if(commandName == "align.seqs")                    {   command = new AlignCommand(optionString);                                   }
294                 else if(commandName == "summary.seqs")                  {       command = new SeqSummaryCommand(optionString);                          }
295                 else if(commandName == "screen.seqs")                   {       command = new ScreenSeqsCommand(optionString);                          }
296                 else if(commandName == "reverse.seqs")                  {       command = new ReverseSeqsCommand(optionString);                         }
297                 else if(commandName == "trim.seqs")                             {       command = new TrimSeqsCommand(optionString);                            }
298                 else if(commandName == "chimera.seqs")                  {       command = new ChimeraSeqsCommand(optionString);                         }
299                 else if(commandName == "list.seqs")                             {       command = new ListSeqsCommand(optionString);                            }
300                 else if(commandName == "get.seqs")                              {       command = new GetSeqsCommand(optionString);                                     }
301                 else if(commandName == "remove.seqs")                   {       command = new RemoveSeqsCommand(optionString);                          }
302                 else if(commandName == "merge.files")                   {       command = new MergeFileCommand(optionString);                           }
303                 else if(commandName == "system")                                {       command = new SystemCommand(optionString);                                      }
304                 else if(commandName == "align.check")                   {       command = new AlignCheckCommand(optionString);                          }
305                 else if(commandName == "get.sharedseqs")                {       command = new GetSharedOTUCommand(optionString);                        }
306                 else if(commandName == "get.otulist")                   {       command = new GetListCountCommand(optionString);                        }
307                 else if(commandName == "hcluster")                              {       command = new HClusterCommand(optionString);                            }
308                 else if(commandName == "classify.seqs")                 {       command = new ClassifySeqsCommand(optionString);                        }
309                 else if(commandName == "chimera.ccode")                 {       command = new ChimeraCcodeCommand(optionString);                        }
310                 else if(commandName == "chimera.check")                 {       command = new ChimeraCheckCommand(optionString);                        }
311                 else if(commandName == "chimera.slayer")                {       command = new ChimeraSlayerCommand(optionString);                       }
312                 else if(commandName == "chimera.pintail")               {       command = new ChimeraPintailCommand(optionString);                      }
313                 else if(commandName == "chimera.bellerophon")   {       command = new ChimeraBellerophonCommand(optionString);          }
314                 else if(commandName == "phylotype")                             {       command = new PhylotypeCommand(optionString);                           }
315                 else if(commandName == "mgcluster")                             {       command = new MGClusterCommand(optionString);                           }
316                 else if(commandName == "pre.cluster")                   {       command = new PreClusterCommand(optionString);                          }
317                 else if(commandName == "pcoa")                                  {       command = new PCACommand(optionString);                                         }
318                 else if(commandName == "otu.hierarchy")                 {       command = new OtuHierarchyCommand(optionString);                        }
319                 else if(commandName == "set.dir")                               {       command = new SetDirectoryCommand(optionString);                        }
320                 else if(commandName == "set.logfile")                   {       command = new SetLogFileCommand(optionString);                          }
321                 else if(commandName == "parse.list")                    {       command = new ParseListCommand(optionString);                           }
322                 else if(commandName == "parse.sff")                             {       command = new ParseSFFCommand(optionString);                            }
323                 else if(commandName == "phylo.diversity")               {       command = new PhyloDiversityCommand(optionString);                      }
324                 else if(commandName == "make.group")                    {       command = new MakeGroupCommand(optionString);                           }
325                 else if(commandName == "chop.seqs")                             {       command = new ChopSeqsCommand(optionString);                            }
326                 else if(commandName == "clearcut")                              {       command = new ClearcutCommand(optionString);                            }
327                 else if(commandName == "catchall")                              {       command = new CatchAllCommand(optionString);                            }
328                 else if(commandName == "split.abund")                   {       command = new SplitAbundCommand(optionString);                          }
329                 else if(commandName == "cluster.split")                 {       command = new ClusterSplitCommand(optionString);                        }
330                 else if(commandName == "classify.otu")                  {       command = new ClassifyOtuCommand(optionString);                         }
331                 else if(commandName == "degap.seqs")                    {       command = new DegapSeqsCommand(optionString);                           }
332                 else if(commandName == "get.relabund")                  {       command = new GetRelAbundCommand(optionString);                         }
333                 else if(commandName == "sens.spec")                             {       command = new SensSpecCommand(optionString);                            }
334                 else if(commandName == "seq.error")                             {       command = new SeqErrorCommand(optionString);                            }
335                 else if(commandName == "sffinfo")                               {       command = new SffInfoCommand(optionString);                                     }
336                 else if(commandName == "normalize.shared")              {       command = new NormalizeSharedCommand(optionString);                     }
337                 else if(commandName == "metastats")                             {       command = new MetaStatsCommand(optionString);                           }
338                 else if(commandName == "split.groups")                  {       command = new SplitGroupCommand(optionString);                          }
339                 else if(commandName == "cluster.fragments")             {       command = new ClusterFragmentsCommand(optionString);            }
340                 else if(commandName == "get.lineage")                   {       command = new GetLineageCommand(optionString);                          }
341                 else if(commandName == "remove.lineage")                {       command = new RemoveLineageCommand(optionString);                       }
342                 else if(commandName == "fastq.info")                    {       command = new ParseFastaQCommand(optionString);                         }
343                 else if(commandName == "pipeline.pds")                  {       command = new PipelineCommand(optionString);                            }
344                 else if(commandName == "deunique.seqs")                 {       command = new DeUniqueSeqsCommand(optionString);                        }
345                 else if(commandName == "pairwise.seqs")                 {       command = new PairwiseSeqsCommand(optionString);                        }
346                 else if(commandName == "cluster.classic")               {       command = new ClusterDoturCommand(optionString);                        }
347                 else                                                                                    {       command = new NoCommand(optionString);                                          }
348
349                 return command;
350         }
351         catch(exception& e) {
352                 m->errorOut(e, "CommandFactory", "getCommand");
353                 exit(1);
354         }
355 }
356 /***********************************************************/
357
358 /***********************************************************/
359 //This function calls the appropriate command fucntions based on user input.
360 Command* CommandFactory::getCommand(string commandName, string optionString, string mode){
361         try {
362                 delete pipecommand;   //delete the old command
363                 
364                 //user has opted to redirect output from dir where input files are located to some other place
365                 if (outputDir != "") { 
366                         if (optionString != "") { optionString += ", outputdir=" + outputDir; }
367                         else { optionString += "outputdir=" + outputDir; }
368                 }
369                 
370                 //user has opted to redirect input from dir where mothur.exe is located to some other place
371                 if (inputDir != "") { 
372                         if (optionString != "") { optionString += ", inputdir=" + inputDir; }
373                         else { optionString += "inputdir=" + inputDir; }
374                 }
375                 
376                 if(commandName == "read.dist")                                  {       pipecommand = new ReadDistCommand(optionString);                                }
377                 else if(commandName == "read.otu")                              {       pipecommand = new ReadOtuCommand(optionString);                                 }
378                 else if(commandName == "read.tree")                             {       pipecommand = new ReadTreeCommand(optionString);                                }
379                 else if(commandName == "cluster")                               {       pipecommand = new ClusterCommand(optionString);                                 }
380                 else if(commandName == "unique.seqs")                   {       pipecommand = new DeconvoluteCommand(optionString);                             }
381                 else if(commandName == "parsimony")                             {       pipecommand = new ParsimonyCommand(optionString);                               }
382                 else if(commandName == "help")                                  {       pipecommand = new HelpCommand(optionString);                                    }
383                 else if(commandName == "quit")                                  {       pipecommand = new QuitCommand(optionString);                                    }
384                 else if(commandName == "collect.single")                {       pipecommand = new CollectCommand(optionString);                                 }
385                 else if(commandName == "collect.shared")                {       pipecommand = new CollectSharedCommand(optionString);                   }
386                 else if(commandName == "rarefaction.single")    {       pipecommand = new RareFactCommand(optionString);                                }
387                 else if(commandName == "rarefaction.shared")    {       pipecommand = new RareFactSharedCommand(optionString);                  }
388                 else if(commandName == "summary.single")                {       pipecommand = new SummaryCommand(optionString);                                 }
389                 else if(commandName == "summary.shared")                {       pipecommand = new SummarySharedCommand(optionString);                   }
390                 else if(commandName == "unifrac.weighted")              {       pipecommand = new UnifracWeightedCommand(optionString);                 }
391                 else if(commandName == "unifrac.unweighted")    {       pipecommand = new UnifracUnweightedCommand(optionString);               }
392                 else if(commandName == "get.group")             {   pipecommand = new GetgroupCommand(optionString);                            }
393                 else if(commandName == "get.label")             {   pipecommand = new GetlabelCommand(optionString);                            }
394                 else if(commandName == "get.sabund")            {   pipecommand = new GetSAbundCommand(optionString);                           }
395                 else if(commandName == "get.rabund")            {   pipecommand = new GetRAbundCommand(optionString);                           }
396                 else if(commandName == "libshuff")              {   pipecommand = new LibShuffCommand(optionString);                            }
397                 else if(commandName == "heatmap.bin")                   {   pipecommand = new HeatMapCommand(optionString);                                     }
398                 else if(commandName == "heatmap.sim")                   {   pipecommand = new HeatMapSimCommand(optionString);                          }
399                 else if(commandName == "filter.seqs")                   {   pipecommand = new FilterSeqsCommand(optionString);                          }
400                 else if(commandName == "venn")                                  {   pipecommand = new VennCommand(optionString);                                        }
401                 else if(commandName == "bin.seqs")                              {   pipecommand = new BinSeqCommand(optionString);                                      }
402                 else if(commandName == "get.oturep")                    {   pipecommand = new GetOTURepCommand(optionString);                           }
403                 else if(commandName == "tree.shared")                   {   pipecommand = new TreeGroupCommand(optionString);                           }
404                 else if(commandName == "dist.shared")                   {   pipecommand = new MatrixOutputCommand(optionString);                        }
405                 else if(commandName == "bootstrap.shared")              {   pipecommand = new BootSharedCommand(optionString);                          }
406                 else if(commandName == "consensus")                             {   pipecommand = new ConcensusCommand(optionString);                           }
407                 else if(commandName == "dist.seqs")                             {   pipecommand = new DistanceCommand(optionString);                            }
408                 else if(commandName == "align.seqs")                    {   pipecommand = new AlignCommand(optionString);                                       }
409                 else if(commandName == "summary.seqs")                  {       pipecommand = new SeqSummaryCommand(optionString);                              }
410                 else if(commandName == "screen.seqs")                   {       pipecommand = new ScreenSeqsCommand(optionString);                              }
411                 else if(commandName == "reverse.seqs")                  {       pipecommand = new ReverseSeqsCommand(optionString);                             }
412                 else if(commandName == "trim.seqs")                             {       pipecommand = new TrimSeqsCommand(optionString);                                }
413                 else if(commandName == "chimera.seqs")                  {       pipecommand = new ChimeraSeqsCommand(optionString);                             }
414                 else if(commandName == "list.seqs")                             {       pipecommand = new ListSeqsCommand(optionString);                                }
415                 else if(commandName == "get.seqs")                              {       pipecommand = new GetSeqsCommand(optionString);                                 }
416                 else if(commandName == "remove.seqs")                   {       pipecommand = new RemoveSeqsCommand(optionString);                              }
417                 else if(commandName == "merge.files")                   {       pipecommand = new MergeFileCommand(optionString);                               }
418                 else if(commandName == "system")                                {       pipecommand = new SystemCommand(optionString);                                  }
419                 else if(commandName == "align.check")                   {       pipecommand = new AlignCheckCommand(optionString);                              }
420                 else if(commandName == "get.sharedseqs")                {       pipecommand = new GetSharedOTUCommand(optionString);                    }
421                 else if(commandName == "get.otulist")                   {       pipecommand = new GetListCountCommand(optionString);                    }
422                 else if(commandName == "hcluster")                              {       pipecommand = new HClusterCommand(optionString);                                }
423                 else if(commandName == "classify.seqs")                 {       pipecommand = new ClassifySeqsCommand(optionString);                    }
424                 else if(commandName == "chimera.ccode")                 {       pipecommand = new ChimeraCcodeCommand(optionString);                    }
425                 else if(commandName == "chimera.check")                 {       pipecommand = new ChimeraCheckCommand(optionString);                    }
426                 else if(commandName == "chimera.slayer")                {       pipecommand = new ChimeraSlayerCommand(optionString);                   }
427                 else if(commandName == "chimera.pintail")               {       pipecommand = new ChimeraPintailCommand(optionString);                  }
428                 else if(commandName == "chimera.bellerophon")   {       pipecommand = new ChimeraBellerophonCommand(optionString);              }
429                 else if(commandName == "phylotype")                             {       pipecommand = new PhylotypeCommand(optionString);                               }
430                 else if(commandName == "mgcluster")                             {       pipecommand = new MGClusterCommand(optionString);                               }
431                 else if(commandName == "pre.cluster")                   {       pipecommand = new PreClusterCommand(optionString);                              }
432                 else if(commandName == "pcoa")                                  {       pipecommand = new PCACommand(optionString);                                             }
433                 else if(commandName == "otu.hierarchy")                 {       pipecommand = new OtuHierarchyCommand(optionString);                    }
434                 else if(commandName == "set.dir")                               {       pipecommand = new SetDirectoryCommand(optionString);                    }
435                 else if(commandName == "set.logfile")                   {       pipecommand = new SetLogFileCommand(optionString);                              }
436                 else if(commandName == "parse.list")                    {       pipecommand = new ParseListCommand(optionString);                               }
437                 else if(commandName == "parse.sff")                             {       pipecommand = new ParseSFFCommand(optionString);                                }
438                 else if(commandName == "phylo.diversity")               {       pipecommand = new PhyloDiversityCommand(optionString);                  }
439                 else if(commandName == "make.group")                    {       pipecommand = new MakeGroupCommand(optionString);                               }
440                 else if(commandName == "chop.seqs")                             {       pipecommand = new ChopSeqsCommand(optionString);                                }
441                 else if(commandName == "clearcut")                              {       pipecommand = new ClearcutCommand(optionString);                                }
442                 else if(commandName == "catchall")                              {       pipecommand = new CatchAllCommand(optionString);                                }
443                 else if(commandName == "split.abund")                   {       pipecommand = new SplitAbundCommand(optionString);                              }
444                 else if(commandName == "cluster.split")                 {       pipecommand = new ClusterSplitCommand(optionString);                    }
445                 else if(commandName == "classify.otu")                  {       pipecommand = new ClassifyOtuCommand(optionString);                             }
446                 else if(commandName == "degap.seqs")                    {       pipecommand = new DegapSeqsCommand(optionString);                               }
447                 else if(commandName == "get.relabund")                  {       pipecommand = new GetRelAbundCommand(optionString);                             }
448                 else if(commandName == "sens.spec")                             {       pipecommand = new SensSpecCommand(optionString);                                }
449                 else if(commandName == "seq.error")                             {       pipecommand = new SeqErrorCommand(optionString);                                }
450                 else if(commandName == "sffinfo")                               {       pipecommand = new SffInfoCommand(optionString);                                 }
451                 else if(commandName == "normalize.shared")              {       pipecommand = new NormalizeSharedCommand(optionString);                 }
452                 else if(commandName == "metastats")                             {       pipecommand = new MetaStatsCommand(optionString);                               }
453                 else if(commandName == "split.groups")                  {       pipecommand = new SplitGroupCommand(optionString);                              }
454                 else if(commandName == "cluster.fragments")             {       pipecommand = new ClusterFragmentsCommand(optionString);                }
455                 else if(commandName == "get.lineage")                   {       pipecommand = new GetLineageCommand(optionString);                              }
456                 else if(commandName == "remove.lineage")                {       pipecommand = new RemoveLineageCommand(optionString);                   }
457                 else if(commandName == "fastq.info")                    {       pipecommand = new ParseFastaQCommand(optionString);                             }
458                 else if(commandName == "deunique.seqs")                 {       pipecommand = new DeUniqueSeqsCommand(optionString);                    }
459                 else if(commandName == "pairwise.seqs")                 {       pipecommand = new PairwiseSeqsCommand(optionString);                    }
460                 else if(commandName == "cluster.classic")               {       pipecommand = new ClusterDoturCommand(optionString);                    }
461                 else                                                                                    {       pipecommand = new NoCommand(optionString);                                              }
462
463                 return pipecommand;
464         }
465         catch(exception& e) {
466                 m->errorOut(e, "CommandFactory", "getCommand");
467                 exit(1);
468         }
469 }
470 /***********************************************************/
471
472 /***********************************************************/
473 //This function calls the appropriate command fucntions based on user input, this is used by the pipeline command to check a users piepline for errors before running
474 Command* CommandFactory::getCommand(string commandName){
475         try {
476                 delete shellcommand;   //delete the old command
477                 
478                 if(commandName == "read.dist")                                  {       shellcommand = new ReadDistCommand();                           }
479                 else if(commandName == "read.otu")                              {       shellcommand = new ReadOtuCommand();                            }
480                 else if(commandName == "read.tree")                             {       shellcommand = new ReadTreeCommand();                           }
481                 else if(commandName == "cluster")                               {       shellcommand = new ClusterCommand();                            }
482                 else if(commandName == "unique.seqs")                   {       shellcommand = new DeconvoluteCommand();                        }
483                 else if(commandName == "parsimony")                             {       shellcommand = new ParsimonyCommand();                          }
484                 else if(commandName == "help")                                  {       shellcommand = new HelpCommand();                                       }
485                 else if(commandName == "quit")                                  {       shellcommand = new QuitCommand();                                       }
486                 else if(commandName == "collect.single")                {       shellcommand = new CollectCommand();                            }
487                 else if(commandName == "collect.shared")                {       shellcommand = new CollectSharedCommand();                      }
488                 else if(commandName == "rarefaction.single")    {       shellcommand = new RareFactCommand();                           }
489                 else if(commandName == "rarefaction.shared")    {       shellcommand = new RareFactSharedCommand();                     }
490                 else if(commandName == "summary.single")                {       shellcommand = new SummaryCommand();                            }
491                 else if(commandName == "summary.shared")                {       shellcommand = new SummarySharedCommand();                      }
492                 else if(commandName == "unifrac.weighted")              {       shellcommand = new UnifracWeightedCommand();            }
493                 else if(commandName == "unifrac.unweighted")    {       shellcommand = new UnifracUnweightedCommand();          }
494                 else if(commandName == "get.group")             {   shellcommand = new GetgroupCommand();                               }
495                 else if(commandName == "get.label")             {   shellcommand = new GetlabelCommand();                               }
496                 else if(commandName == "get.sabund")            {   shellcommand = new GetSAbundCommand();                              }
497                 else if(commandName == "get.rabund")            {   shellcommand = new GetRAbundCommand();                              }
498                 else if(commandName == "libshuff")              {   shellcommand = new LibShuffCommand();                               }
499                 else if(commandName == "heatmap.bin")                   {   shellcommand = new HeatMapCommand();                                }
500                 else if(commandName == "heatmap.sim")                   {   shellcommand = new HeatMapSimCommand();                             }
501                 else if(commandName == "filter.seqs")                   {   shellcommand = new FilterSeqsCommand();                             }
502                 else if(commandName == "venn")                                  {   shellcommand = new VennCommand();                                   }
503                 else if(commandName == "bin.seqs")                              {   shellcommand = new BinSeqCommand();                                 }
504                 else if(commandName == "get.oturep")                    {   shellcommand = new GetOTURepCommand();                              }
505                 else if(commandName == "tree.shared")                   {   shellcommand = new TreeGroupCommand();                              }
506                 else if(commandName == "dist.shared")                   {   shellcommand = new MatrixOutputCommand();                   }
507                 else if(commandName == "bootstrap.shared")              {   shellcommand = new BootSharedCommand();                             }
508                 else if(commandName == "consensus")                             {   shellcommand = new ConcensusCommand();                              }
509                 else if(commandName == "dist.seqs")                             {   shellcommand = new DistanceCommand();                               }
510                 else if(commandName == "align.seqs")                    {   shellcommand = new AlignCommand();                                  }
511                 else if(commandName == "summary.seqs")                  {       shellcommand = new SeqSummaryCommand();                         }
512                 else if(commandName == "screen.seqs")                   {       shellcommand = new ScreenSeqsCommand();                         }
513                 else if(commandName == "reverse.seqs")                  {       shellcommand = new ReverseSeqsCommand();                        }
514                 else if(commandName == "trim.seqs")                             {       shellcommand = new TrimSeqsCommand();                           }
515                 else if(commandName == "chimera.seqs")                  {       shellcommand = new ChimeraSeqsCommand();                        }
516                 else if(commandName == "list.seqs")                             {       shellcommand = new ListSeqsCommand();                           }
517                 else if(commandName == "get.seqs")                              {       shellcommand = new GetSeqsCommand();                            }
518                 else if(commandName == "remove.seqs")                   {       shellcommand = new RemoveSeqsCommand();                         }
519                 else if(commandName == "merge.files")                   {       shellcommand = new MergeFileCommand();                          }
520                 else if(commandName == "system")                                {       shellcommand = new SystemCommand();                                     }
521                 else if(commandName == "align.check")                   {       shellcommand = new AlignCheckCommand();                         }
522                 else if(commandName == "get.sharedseqs")                {       shellcommand = new GetSharedOTUCommand();                       }
523                 else if(commandName == "get.otulist")                   {       shellcommand = new GetListCountCommand();                       }
524                 else if(commandName == "hcluster")                              {       shellcommand = new HClusterCommand();                           }
525                 else if(commandName == "classify.seqs")                 {       shellcommand = new ClassifySeqsCommand();                       }
526                 else if(commandName == "chimera.ccode")                 {       shellcommand = new ChimeraCcodeCommand();                       }
527                 else if(commandName == "chimera.check")                 {       shellcommand = new ChimeraCheckCommand();                       }
528                 else if(commandName == "chimera.slayer")                {       shellcommand = new ChimeraSlayerCommand();                      }
529                 else if(commandName == "chimera.pintail")               {       shellcommand = new ChimeraPintailCommand();                     }
530                 else if(commandName == "chimera.bellerophon")   {       shellcommand = new ChimeraBellerophonCommand();         }
531                 else if(commandName == "phylotype")                             {       shellcommand = new PhylotypeCommand();                          }
532                 else if(commandName == "mgcluster")                             {       shellcommand = new MGClusterCommand();                          }
533                 else if(commandName == "pre.cluster")                   {       shellcommand = new PreClusterCommand();                         }
534                 else if(commandName == "pcoa")                                  {       shellcommand = new PCACommand();                                        }
535                 else if(commandName == "otu.hierarchy")                 {       shellcommand = new OtuHierarchyCommand();                       }
536                 else if(commandName == "set.dir")                               {       shellcommand = new SetDirectoryCommand();                       }
537                 else if(commandName == "set.logfile")                   {       shellcommand = new SetLogFileCommand();                         }
538                 else if(commandName == "parse.list")                    {       shellcommand = new ParseListCommand();                          }
539                 else if(commandName == "parse.sff")                             {       shellcommand = new ParseSFFCommand();                           }
540                 else if(commandName == "phylo.diversity")               {       shellcommand = new PhyloDiversityCommand();                     }
541                 else if(commandName == "make.group")                    {       shellcommand = new MakeGroupCommand();                          }
542                 else if(commandName == "chop.seqs")                             {       shellcommand = new ChopSeqsCommand();                           }
543                 else if(commandName == "clearcut")                              {       shellcommand = new ClearcutCommand();                           }
544                 else if(commandName == "catchall")                              {       shellcommand = new CatchAllCommand();                           }
545                 else if(commandName == "split.abund")                   {       shellcommand = new SplitAbundCommand();                         }
546                 else if(commandName == "cluster.split")                 {       shellcommand = new ClusterSplitCommand();                       }
547                 else if(commandName == "classify.otu")                  {       shellcommand = new ClassifyOtuCommand();                        }
548                 else if(commandName == "degap.seqs")                    {       shellcommand = new DegapSeqsCommand();                          }
549                 else if(commandName == "get.relabund")                  {       shellcommand = new GetRelAbundCommand();                        }
550                 else if(commandName == "sens.spec")                             {       shellcommand = new SensSpecCommand();                           }
551                 else if(commandName == "seq.error")                             {       shellcommand = new SeqErrorCommand();                           }
552                 else if(commandName == "sffinfo")                               {       shellcommand = new SffInfoCommand();                            }
553                 else if(commandName == "normalize.shared")              {       shellcommand = new NormalizeSharedCommand();            }
554                 else if(commandName == "metastats")                             {       shellcommand = new MetaStatsCommand();                          }
555                 else if(commandName == "split.groups")                  {       shellcommand = new SplitGroupCommand();                         }
556                 else if(commandName == "cluster.fragments")             {       shellcommand = new ClusterFragmentsCommand();           }
557                 else if(commandName == "get.lineage")                   {       shellcommand = new GetLineageCommand();                         }
558                 else if(commandName == "remove.lineage")                {       shellcommand = new RemoveLineageCommand();                      }
559                 else if(commandName == "fastq.info")                    {       shellcommand = new ParseFastaQCommand();                        }
560                 else if(commandName == "deunique.seqs")                 {       shellcommand = new DeUniqueSeqsCommand();                       }
561                 else if(commandName == "pairwise.seqs")                 {       shellcommand = new PairwiseSeqsCommand();                       }
562                 else if(commandName == "cluster.classic")               {       shellcommand = new ClusterDoturCommand();                       }
563                 else                                                                                    {       shellcommand = new NoCommand();                                         }
564
565                 return shellcommand;
566         }
567         catch(exception& e) {
568                 m->errorOut(e, "CommandFactory", "getCommand");
569                 exit(1);
570         }
571 }
572 /***********************************************************
573 //This function is used to interrupt a command
574 Command* CommandFactory::getCommand(){
575         try {
576                 delete command;   //delete the old command
577
578                 string s = "";
579             command = new NoCommand(s);
580         
581                 return command;
582         }
583         catch(exception& e) {
584                 m->errorOut(e, "CommandFactory", "getCommand");
585                 exit(1);
586         }
587 }
588 /***********************************************************************/
589 bool CommandFactory::isValidCommand(string command) {
590         try {   
591         
592                 //is the command in the map
593                 if ((commands.find(command)) != (commands.end())) {
594                         return true;
595                 }else{
596                         m->mothurOut(command + " is not a valid command in Mothur.  Valid commands are ");
597                         for (it = commands.begin(); it != commands.end(); it++) {
598                                 m->mothurOut(it->first + ", ");
599                         }
600                         m->mothurOutEndLine();
601                         return false;
602                 }
603                 
604         }
605         catch(exception& e) {
606                 m->errorOut(e, "CommandFactory", "isValidCommand");
607                 exit(1);
608         }
609 }
610 /***********************************************************************/
611 bool CommandFactory::isValidCommand(string command, string noError) {
612         try {   
613         
614                 //is the command in the map
615                 if ((commands.find(command)) != (commands.end())) {
616                         return true;
617                 }else{
618                         return false;
619                 }
620                 
621         }
622         catch(exception& e) {
623                 m->errorOut(e, "CommandFactory", "isValidCommand");
624                 exit(1);
625         }
626 }
627 /***********************************************************************/
628 void CommandFactory::printCommands(ostream& out) {
629         try {   
630                 out << "Valid commands are: ";
631                 for (it = commands.begin(); it != commands.end(); it++) {
632                         out << it->first << ",";
633                 }
634                 out << endl;
635         }
636         catch(exception& e) {
637                 m->errorOut(e, "CommandFactory", "printCommands");
638                 exit(1);
639         }
640 }
641 /***********************************************************************/
642
643
644
645