#include <iomanip>
#include <fstream>
#include <sstream>
+#include <signal.h>
+
//exception
#include <stdexcept>
#include <ctime>
#include <limits>
-using namespace std;
+/***********************************************************************/
-#ifdef _WIN32
- #define exp(x) (exp((double) x))
- #define sqrt(x) (sqrt((double) x))
- #define log10(x) (log10((double) x))
- #define log2(x) (log10(x)/log10(2))
- #define isnan(x) ((x) != (x))
- #define isinf(x) (fabs(x) == std::numeric_limits<double>::infinity())
-#else
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
#include <sys/wait.h>
#include <unistd.h>
+
+ #ifdef USE_READLINE
+ #include <readline/readline.h>
+ #include <readline/history.h>
+ #endif
+
+ //#include <readline/readline.h>
+ //#include <readline/history.h>
+#else
+ #include <conio.h> //allows unbuffered screen capture from stdin
+ #include <direct.h> //get cwd
#endif
+using namespace std;
-typedef unsigned long long ull;
+#define exp(x) (exp((double) x))
+#define sqrt(x) (sqrt((double) x))
+#define log10(x) (log10((double) x))
+#define log2(x) (log10(x)/log10(2))
+#define isnan(x) ((x) != (x))
+#define isinf(x) (fabs(x) == std::numeric_limits<double>::infinity())
+
+typedef unsigned long ull;
struct IntNode {
int lvalue;
int rcoef;
IntNode* left;
IntNode* right;
+
+ IntNode(int lv, int rv, IntNode* l, IntNode* r) : lvalue(lv), rvalue(rv), left(l), right(r) {};
+ IntNode() {};
};
struct ThreadNode {
IntNode* right;
};
+/************************************************************/
+struct clusterNode {
+ int numSeq;
+ int parent;
+ int smallChild; //used to make linkTable work with list and rabund. represents bin number of this cluster node
+ clusterNode(int num, int par, int kid) : numSeq(num), parent(par), smallChild(kid) {};
+};
+/************************************************************/
+struct seqDist {
+ int seq1;
+ int seq2;
+ float dist;
+ seqDist() {}
+ seqDist(int s1, int s2, float d) : seq1(s1), seq2(s2), dist(d) {}
+ ~seqDist() {}
+};
+//********************************************************************************************************************
+//sorts lowest to highest
+inline bool compareSequenceDistance(seqDist left, seqDist right){
+ return (left.dist < right.dist);
+}
/***********************************************************************/
// snagged from http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.2
if (!(i >> x) || (failIfLeftoverChars && i.get(c)))
throw BadConversion(s);
}
+
//**********************************************************************************************************************
template<typename T>
char c;
if (!(i >> x) || (failIfLeftoverChars && i.get(c)))
{
- cout << "'" << s << "' is unable to be converted into an integer.\n";
+ cout << "unable to be converted into an integer.\n" << endl;
return false;
}
return true;
return output.str();
}
+/***********************************************************************/
+inline int openOutputFileAppend(string fileName, ofstream& fileHandle){
+
+ fileHandle.open(fileName.c_str(), ios::app);
+ if(!fileHandle) {
+ cout << "Error: Could not open " << fileName << endl;
+ return 1;
+ }
+ else {
+ return 0;
+ }
+}
/***********************************************************************/
inline void gobble(istream& f){
}
/***********************************************************************/
+inline string getline(ifstream& fileHandle) {
+ try {
+
+ string line = "";
+
+ while (!fileHandle.eof()) {
+ //get next character
+ char c = fileHandle.get();
+
+ //are you at the end of the line
+ if ((c == '\n') || (c == '\r') || (c == '\f')){ break; }
+ else { line += c; }
+ }
+
+ return line;
+
+ }
+ catch(exception& e) {
+ cout << "Error in mothur function getline" << endl;
+ exit(1);
+ }
+}
+
+/**************************************************************************************************/
+
+inline void mothurOut(string message) {
+ try{
+ ofstream out;
+ string logFileName = "mothur.logFile";
+ openOutputFileAppend(logFileName, out);
+
+ cout << message;
+ out << message;
+
+ out.close();
+ }
+ catch(exception& e) {
+ cout << "Error in mothur class mothurOut" << endl;
+ exit(1);
+ }
+}
+/**************************************************************************************************/
+
+inline void mothurOut(string message, string precision) {
+ try{
+ ofstream out;
+ string logFileName = "mothur.logFile";
+ openOutputFileAppend(logFileName, out);
+
+ cout << precision << message;
+ out << precision << message;
+
+ out.close();
+ }
+ catch(exception& e) {
+ cout << "Error in mothur class mothurOut" << endl;
+ exit(1);
+ }
+}
+
+/**************************************************************************************************/
+
+inline void mothurOutEndLine() {
+ try {
+ ofstream out;
+ string logFileName = "mothur.logFile";
+ openOutputFileAppend(logFileName, out);
+
+ cout << endl;
+ out << endl;
+
+ out.close();
+ }
+ catch(exception& e) {
+ cout << "error in mothur mothurOutEndLine" << endl;
+ exit(1);
+ }
+}
+
+
+/**************************************************************************************************/
+
+inline void errorOut(exception& e, string object, string function) {
+
+ mothurOut("Error: ");
+ mothurOut(toString(e.what()));
+ mothurOut(" has occurred in the " + object + " class function " + function + ". Please contact Pat Schloss at mothur.bugs@gmail.com, and be sure to include the mothur.logFile with your inquiry.");
+ mothurOutEndLine();
+
+}
+
+/***********************************************************************/
+
inline bool isTrue(string f){
if ((f == "TRUE") || (f == "T") || (f == "true") || (f == "t")) { return true; }
string simpleName = longName;
- if(longName.find_last_of("/") != longName.npos){
- int pos = longName.find_last_of('/')+1;
- simpleName = longName.substr(pos, longName.length());
- }
+ size_t found;
+ found=longName.find_last_of("/\\");
+ if(found != longName.npos){
+ simpleName = longName.substr(found+1);
+ }
+
+ //if(longName.find_last_of("/") != longName.npos){
+ // int pos = longName.find_last_of('/')+1;
+ // simpleName = longName.substr(pos, longName.length());
+ //}
+
return simpleName;
}
string rootPathName = longName;
- if(longName.find_last_of('/') != longName.npos){
- int pos = longName.find_last_of('/')+1;
+ if(longName.find_last_of("/\\") != longName.npos){
+ int pos = longName.find_last_of("/\\")+1;
rootPathName = longName.substr(0, pos);
}
-
+
return rootPathName;
}
+/***********************************************************************/
+
+inline string hasPath(string longName){
+
+ string path = "";
+
+ size_t found;
+ found=longName.find_last_of("/\\");
+
+ if(found != longName.npos){
+ path = longName.substr(0, found+1);
+ }
+
+ return path;
+}
/***********************************************************************/
return extension;
}
-
/***********************************************************************/
-
-inline int openInputFile(string fileName, ifstream& fileHandle){
-
+inline bool isBlank(string fileName){
+
+ ifstream fileHandle;
fileHandle.open(fileName.c_str());
if(!fileHandle) {
- cerr << "Error: Could not open " << fileName << endl;
- return 1;
+ mothurOut("Error: Could not open " + fileName); mothurOutEndLine();
+ return false;
+ }else {
+ //check for blank file
+ gobble(fileHandle);
+ if (fileHandle.eof()) { fileHandle.close(); return true; }
}
- else {
- return 0;
+ return false;
+}
+/***********************************************************************/
+
+inline string getFullPathName(string fileName){
+
+ string path = hasPath(fileName);
+ string newFileName;
+ int pos;
+
+ if (path == "") { return fileName; } //its a simple name
+ else { //we need to complete the pathname
+ // ex. ../../../filename
+ // cwd = /user/work/desktop
+
+ string cwd;
+ //get current working directory
+ #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
+ if (path.rfind("./") == -1) { return fileName; } //already complete name
+ else { newFileName = fileName.substr(fileName.rfind("./")+2); } //save the complete part of the name
+
+ char* cwdpath;
+ size_t size;
+ cwdpath=getcwd(cwdpath,size);
+ cwd = cwdpath;
+
+ //rip off first '/'
+ string simpleCWD;
+ if (cwd.length() > 0) { simpleCWD = cwd.substr(1); }
+
+ //break apart the current working directory
+ vector<string> dirs;
+ while (simpleCWD.find_first_of('/') != -1) {
+ string dir = simpleCWD.substr(0,simpleCWD.find_first_of('/'));
+ simpleCWD = simpleCWD.substr(simpleCWD.find_first_of('/')+1, simpleCWD.length());
+ dirs.push_back(dir);
+ }
+ //get last one // ex. ../../../filename = /user/work/desktop/filename
+ dirs.push_back(simpleCWD); //ex. dirs[0] = user, dirs[1] = work, dirs[2] = desktop
+
+ int index = dirs.size()-1;
+
+ while((pos = path.rfind("./")) != -1) { //while you don't have a complete path
+ if (path[(pos-1)] == '.') { //you want your parent directory ../
+ path = path.substr(0, pos-1);
+ index--;
+ if (index == 0) { break; }
+ }else if (path[(pos-1)] == '/') { //you want the current working dir ./
+ path = path.substr(0, pos);
+ }else if (pos == 1) { break;
+ }else { mothurOut("cannot resolve path for " + fileName); mothurOutEndLine(); return fileName; }
+ }
+
+ for (int i = index; i >= 0; i--) {
+ newFileName = dirs[i] + "/" + newFileName;
+ }
+
+ newFileName = "/" + newFileName;
+ return newFileName;
+
+ #else
+ if (path.rfind(".\\") == -1) { return fileName; } //already complete name
+ else { newFileName = fileName.substr(fileName.rfind(".\\")+2); } //save the complete part of the name
+
+ char *cwdpath = NULL;
+ cwdpath = getcwd(NULL, 0); // or _getcwd
+ if ( cwdpath != NULL) { cwd = cwdpath; }
+ else { cwd = ""; }
+
+ //break apart the current working directory
+ vector<string> dirs;
+ while (cwd.find_first_of('\\') != -1) {
+ string dir = cwd.substr(0,cwd.find_first_of('\\'));
+ cwd = cwd.substr(cwd.find_first_of('\\')+1, cwd.length());
+ dirs.push_back(dir);
+
+ }
+ //get last one
+ dirs.push_back(cwd); //ex. dirs[0] = user, dirs[1] = work, dirs[2] = desktop
+
+ int index = dirs.size()-1;
+
+ while((pos = path.rfind(".\\")) != -1) { //while you don't have a complete path
+ if (path[(pos-1)] == '.') { //you want your parent directory ../
+ path = path.substr(0, pos-1);
+ index--;
+ if (index == 0) { break; }
+ }else if (path[(pos-1)] == '\\') { //you want the current working dir ./
+ path = path.substr(0, pos);
+ }else if (pos == 1) { break;
+ }else { mothurOut("cannot resolve path for " + fileName); mothurOutEndLine(); return fileName; }
+ }
+
+ for (int i = index; i >= 0; i--) {
+ newFileName = dirs[i] + "\\" + newFileName;
+ }
+
+ return newFileName;
+
+ #endif
}
}
+/***********************************************************************/
+
+inline int openInputFile(string fileName, ifstream& fileHandle, string m){
+
+ //get full path name
+ string completeFileName = getFullPathName(fileName);
+ fileHandle.open(completeFileName.c_str());
+ if(!fileHandle) {
+ return 1;
+ }else {
+ //check for blank file
+ gobble(fileHandle);
+ return 0;
+ }
+}
/***********************************************************************/
-inline int openOutputFile(string fileName, ofstream& fileHandle){
+inline int openInputFile(string fileName, ifstream& fileHandle){
+ //get full path name
+ string completeFileName = getFullPathName(fileName);
- fileHandle.open(fileName.c_str(), ios::trunc);
+ fileHandle.open(completeFileName.c_str());
if(!fileHandle) {
- cerr << "Error: Could not open " << fileName << endl;
+ mothurOut("Error: Could not open " + completeFileName); mothurOutEndLine();
return 1;
}
else {
+ //check for blank file
+ gobble(fileHandle);
+ if (fileHandle.eof()) { mothurOut(completeFileName + " is blank. Please correct."); mothurOutEndLine(); return 1; }
+
return 0;
}
+
+}
+/***********************************************************************/
+inline int renameFile(string oldName, string newName){
+
+ ifstream inTest;
+ int exist = openInputFile(newName, inTest, "");
+
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
+ if (exist == 0) { //you could open it so you want to delete it
+ inTest.close();
+ string command = "rm " + newName;
+ system(command.c_str());
+ }
+
+ string command = "mv " + oldName + " " + newName;
+ system(command.c_str());
+#else
+ remove(newName.c_str());
+ int renameOk = rename(oldName.c_str(), newName.c_str());
+#endif
+ return 0;
}
+
/***********************************************************************/
-inline int openOutputFileAppend(string fileName, ofstream& fileHandle){
+inline int openOutputFile(string fileName, ofstream& fileHandle){
+
+ string completeFileName = getFullPathName(fileName);
- fileHandle.open(fileName.c_str(), ios::app);
+ fileHandle.open(completeFileName.c_str(), ios::trunc);
if(!fileHandle) {
- cerr << "Error: Could not open " << fileName << endl;
+ mothurOut("Error: Could not open " + completeFileName); mothurOutEndLine();
return 1;
}
else {
}
-
/***********************************************************************/
inline int getNumSeqs(ifstream& file){
return numSeqs;
}
+/***********************************************************************/
+inline bool inVector(string member, vector<string> group){
+
+ for (int i = 0; i < group.size(); i++) {
+ if (group[i] == member) { return true; }
+ }
+
+ return false;
+}
/***********************************************************************/
//This function parses the estimator options and puts them in a vector
container.push_back(estim);
}
catch(exception& e) {
- cout << "Standard Error: " << e.what() << " has occurred in the mothur class Function splitAtDash. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
- exit(1);
- }
- catch(...) {
- cout << "An unknown error has occurred in the mothur class function splitAtDash. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+ errorOut(e, "mothur", "splitAtDash");
exit(1);
}
-
}
/***********************************************************************/
container.insert(estim);
}
catch(exception& e) {
- cout << "Standard Error: " << e.what() << " has occurred in the mothur class Function splitAtDash. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
- exit(1);
- }
- catch(...) {
- cout << "An unknown error has occurred in the mothur class function splitAtDash. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+ errorOut(e, "mothur", "splitAtDash");
exit(1);
}
-
}
/***********************************************************************/
//This function parses the line options and puts them in a set
container.insert(lineNum);
}
catch(exception& e) {
- cout << "Standard Error: " << e.what() << " has occurred in the mothur class Function splitAtDash. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+ errorOut(e, "mothur", "splitAtDash");
exit(1);
}
- catch(...) {
- cout << "An unknown error has occurred in the mothur class function splitAtDash. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
- exit(1);
- }
-
}
/***********************************************************************/
//This function parses the a string and puts peices in a vector
container.push_back(estim);
}
catch(exception& e) {
- cout << "Standard Error: " << e.what() << " has occurred in the mothur class Function splitAtComma. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
- exit(1);
- }
- catch(...) {
- cout << "An unknown error has occurred in the mothur class function splitAtComma. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+ errorOut(e, "mothur", "splitAtComma");
exit(1);
}
}
}
catch(exception& e) {
- cout << "Standard Error: " << e.what() << " has occurred in the mothur class Function splitAtComma. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
- exit(1);
- }
- catch(...) {
- cout << "An unknown error has occurred in the mothur class function splitAtComma. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+ errorOut(e, "mothur", "splitAtComma");
exit(1);
}
-
}
/***********************************************************************/
}
}
catch(exception& e) {
- cout << "Standard Error: " << e.what() << " has occurred in the mothur class Function splitAtEquals. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
- exit(1);
- }
- catch(...) {
- cout << "An unknown error has occurred in the mothur class function splitAtEquals. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+ errorOut(e, "mothur", "splitAtEquals");
exit(1);
}
-
}
/**************************************************************************************************/
return false;
}
catch(exception& e) {
- cout << "Standard Error: " << e.what() << " has occurred in the mothur class Function inUsersGroups. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+ errorOut(e, "mothur", "inUsersGroups");
exit(1);
}
- catch(...) {
- cout << "An unknown error has occurred in the mothur class function inUsersGroups. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+}
+
+/**************************************************************************************************/
+
+inline void mothurOutJustToLog(string message) {
+ try {
+ ofstream out;
+ string logFileName = "mothur.logFile";
+ openOutputFileAppend(logFileName, out);
+
+ out << message;
+
+ out.close();
+ }
+ catch(exception& e) {
+ errorOut(e, "mothur", "mothurOutJustToLog");
+ exit(1);
+ }
+}
+
+
+/**************************************************************************************************/
+
+inline void mothurOut(float num) {
+ try {
+ ofstream out;
+ string logFileName = "mothur.logFile";
+ openOutputFileAppend(logFileName, out);
+
+ cout << num;
+ out << num;
+
+ out.close();
+ }
+ catch(exception& e) {
+ cout << "Error in mothur class mothurOut float" << endl;
+ exit(1);
+ }
+}
+/***********************************************************************/
+inline void mothurOut(double value) {
+ try {
+ ofstream out;
+ string logFileName = "mothur.logFile";
+ openOutputFileAppend(logFileName, out);
+
+ cout << value;
+ out << value;
+
+ out.close();
+ }
+ catch(exception& e) {
+ cout << "Error in mothur class mothurOut double" << endl;
exit(1);
}
}
orderFloat.push_back(-1.0);
userMap["unique"] = -1.0;
}else {
- if (errorOff == "") { cout << *it << " is not a valid label." << endl; }
+ if (errorOff == "") { mothurOut(*it + " is not a valid label."); mothurOutEndLine(); }
userLabels.erase(*it);
it--;
}
if (orderFloat[i] < labelFloat) {
smaller = true;
if (orderFloat[i] == -1) {
- if (errorOff == "") { cout << "Your file does not include the label unique." << endl; }
+ if (errorOff == "") { mothurOut("Your file does not include the label unique."); mothurOutEndLine(); }
userLabels.erase("unique");
}
else {
- if (errorOff == "") { cout << "Your file does not include the label "; }
+ if (errorOff == "") { mothurOut("Your file does not include the label "); mothurOutEndLine(); }
string s = "";
for (it2 = userMap.begin(); it2!= userMap.end(); it2++) {
if (it2->second == orderFloat[i]) {
break;
}
}
- if (errorOff == "") { cout << s << ". I will use the next smallest distance. " << endl; }
+ if (errorOff == "") { mothurOut(s + ". I will use the next smallest distance. "); mothurOutEndLine(); }
}
//since they are sorted once you find a bigger one stop looking
}else { break; }
}
catch(exception& e) {
- cout << "Standard Error: " << e.what() << " has occurred in the mothur class Function anyLabelsToProcess. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+ errorOut(e, "mothur", "anyLabelsToProcess");
exit(1);
}
- catch(...) {
- cout << "An unknown error has occurred in the mothur class function anyLabelsToProcess. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+}
+
+/**************************************************************************************************/
+inline void appendFiles(string temp, string filename) {
+ try{
+ ofstream output;
+ ifstream input;
+
+ //open output file in append mode
+ openOutputFileAppend(filename, output);
+ openInputFile(temp, input);
+
+ while(char c = input.get()){
+ if(input.eof()) { break; }
+ else { output << c; }
+ }
+
+ input.close();
+ output.close();
+ }
+ catch(exception& e) {
+ errorOut(e, "mothur", "appendFiles");
exit(1);
}
-
}
+/**************************************************************************************************/
+inline string sortFile(string distFile){
+ try {
+ string outfile = getRootName(distFile) + "sorted.dist";
+
+ //if you can, use the unix sort since its been optimized for years
+ #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
+ string command = "sort -n -k +3 " + distFile + " -o " + outfile;
+ system(command.c_str());
+ #else //you are stuck with my best attempt...
+ //windows sort does not have a way to specify a column, only a character in the line
+ //since we cannot assume that the distance will always be at the the same character location on each line
+ //due to variable sequence name lengths, I chose to force the distance into first position, then sort and then put it back.
+
+ //read in file line by file and put distance first
+ string tempDistFile = distFile + ".temp";
+ ifstream input;
+ ofstream output;
+ openInputFile(distFile, input);
+ openOutputFile(tempDistFile, output);
+
+ string firstName, secondName;
+ float dist;
+ while (input) {
+ input >> firstName >> secondName >> dist;
+ output << dist << '\t' << firstName << '\t' << secondName << endl;
+ gobble(input);
+ }
+ input.close();
+ output.close();
+
+
+ //sort using windows sort
+ string tempOutfile = outfile + ".temp";
+ string command = "sort " + tempDistFile + " /O " + tempOutfile;
+ system(command.c_str());
+
+ //read in sorted file and put distance at end again
+ ifstream input2;
+ openInputFile(tempOutfile, input2);
+ openOutputFile(outfile, output);
+
+ while (input2) {
+ input2 >> dist >> firstName >> secondName;
+ output << firstName << '\t' << secondName << '\t' << dist << endl;
+ gobble(input2);
+ }
+ input2.close();
+ output.close();
+
+ //remove temp files
+ remove(tempDistFile.c_str());
+ remove(tempOutfile.c_str());
+ #endif
+
+ return outfile;
+ }
+ catch(exception& e) {
+ errorOut(e, "mothur", "sortFile");
+ exit(1);
+ }
+}
/**************************************************************************************************/
#endif
projects / mothur.git / blobdiff