X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=sharedcommand.cpp;h=de48158d9eb7d26adecce2dab1162b32332fec5f;hb=8dd3c225255d7084e3aff8740aa4f1f1cabb367a;hp=89f57eb5ca1aa80bf0d72d5aa47fcdabca6d8ef2;hpb=832d53a9dfac6b1795735eec643d8cf627b0d8e3;p=mothur.git diff --git a/sharedcommand.cpp b/sharedcommand.cpp index 89f57eb..de48158 100644 --- a/sharedcommand.cpp +++ b/sharedcommand.cpp @@ -8,76 +8,252 @@ */ #include "sharedcommand.h" - +//******************************************************************************************************************** +//sorts lowest to highest +inline bool compareSharedRabunds(SharedRAbundVector* left, SharedRAbundVector* right){ + return (left->getGroup() < right->getGroup()); +} +//********************************************************************************************************************** +vector SharedCommand::setParameters(){ + try { + CommandParameter plist("list", "InputTypes", "", "", "none", "none", "none",false,true); parameters.push_back(plist); + CommandParameter pgroup("group", "InputTypes", "", "", "none", "none", "none",false,true); parameters.push_back(pgroup); + //CommandParameter pordergroup("ordergroup", "InputTypes", "", "", "none", "none", "none",false,false); parameters.push_back(pordergroup); + CommandParameter plabel("label", "String", "", "", "", "", "",false,false); parameters.push_back(plabel); + CommandParameter pgroups("groups", "String", "", "", "", "", "",false,false); parameters.push_back(pgroups); + CommandParameter pinputdir("inputdir", "String", "", "", "", "", "",false,false); parameters.push_back(pinputdir); + CommandParameter poutputdir("outputdir", "String", "", "", "", "", "",false,false); parameters.push_back(poutputdir); + + vector myArray; + for (int i = 0; i < parameters.size(); i++) { myArray.push_back(parameters[i].name); } + return myArray; + } + catch(exception& e) { + m->errorOut(e, "SharedCommand", "setParameters"); + exit(1); + } +} +//********************************************************************************************************************** +string SharedCommand::getHelpString(){ + try { + string helpString = ""; + helpString += "The make.shared command reads a list and group file and creates a shared file, as well as a rabund file for each group.\n"; + helpString += "The make.shared command parameters are list, group, ordergroup, groups and label. list and group are required unless a current file is available.\n"; + helpString += "The groups parameter allows you to indicate which groups you want to include, group names should be separated by dashes. ex. groups=A-B-C. Default is all groups in your groupfile.\n"; + helpString += "The label parameter allows you to indicate which labels you want to include, label names should be separated by dashes. Default is all labels in your list file.\n"; + //helpString += "The ordergroup parameter allows you to indicate the order of the groups in the sharedfile, by default the groups are listed alphabetically.\n"; + return helpString; + } + catch(exception& e) { + m->errorOut(e, "SharedCommand", "getHelpString"); + exit(1); + } +} +//********************************************************************************************************************** +SharedCommand::SharedCommand(){ + try { + abort = true; calledHelp = true; + setParameters(); + //initialize outputTypes + vector tempOutNames; + outputTypes["rabund"] = tempOutNames; + outputTypes["shared"] = tempOutNames; + outputTypes["group"] = tempOutNames; + } + catch(exception& e) { + m->errorOut(e, "SharedCommand", "SharedCommand"); + exit(1); + } +} +//********************************************************************************************************************** +SharedCommand::SharedCommand(string option) { + try { + abort = false; calledHelp = false; + allLines = 1; + + //allow user to run help + if(option == "help") { help(); abort = true; calledHelp = true; } + else if(option == "citation") { citation(); abort = true; calledHelp = true;} + + else { + + vector myArray = setParameters(); + + OptionParser parser(option); + map parameters = parser.getParameters(); + + ValidParameters validParameter; + map::iterator it; + + //check to make sure all parameters are valid for command + for (it = parameters.begin(); it != parameters.end(); it++) { + if (validParameter.isValidParameter(it->first, myArray, it->second) != true) { abort = true; } + } + + //if the user changes the input directory command factory will send this info to us in the output parameter + string inputDir = validParameter.validFile(parameters, "inputdir", false); + if (inputDir == "not found"){ inputDir = ""; } + else { + string path; + it = parameters.find("list"); + //user has given a template file + if(it != parameters.end()){ + path = m->hasPath(it->second); + //if the user has not given a path then, add inputdir. else leave path alone. + if (path == "") { parameters["list"] = inputDir + it->second; } + } + + it = parameters.find("group"); + //user has given a template file + if(it != parameters.end()){ + path = m->hasPath(it->second); + //if the user has not given a path then, add inputdir. else leave path alone. + if (path == "") { parameters["group"] = inputDir + it->second; } + } + + it = parameters.find("ordergroup"); + //user has given a template file + if(it != parameters.end()){ + path = m->hasPath(it->second); + //if the user has not given a path then, add inputdir. else leave path alone. + if (path == "") { parameters["ordergroup"] = inputDir + it->second; } + } + } + + + //if the user changes the output directory command factory will send this info to us in the output parameter + outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; } + + //check for required parameters + listfile = validParameter.validFile(parameters, "list", true); + if (listfile == "not open") { listfile = ""; abort = true; } + else if (listfile == "not found") { + listfile = m->getListFile(); + if (listfile != "") { m->mothurOut("Using " + listfile + " as input file for the list parameter."); m->mothurOutEndLine(); } + else { m->mothurOut("You have no current list file and the list parameter is required."); m->mothurOutEndLine(); abort = true; } + }else { m->setListFile(listfile); } + + ordergroupfile = validParameter.validFile(parameters, "ordergroup", true); + if (ordergroupfile == "not open") { abort = true; } + else if (ordergroupfile == "not found") { ordergroupfile = ""; } + + groupfile = validParameter.validFile(parameters, "group", true); + if (groupfile == "not open") { groupfile = ""; abort = true; } + else if (groupfile == "not found") { + groupfile = m->getGroupFile(); + if (groupfile != "") { + m->mothurOut("Using " + groupfile + " as input file for the group parameter."); m->mothurOutEndLine(); + groupMap = new GroupMap(groupfile); + + int error = groupMap->readMap(); + if (error == 1) { abort = true; } + vector allGroups = groupMap->getNamesOfGroups(); + m->setAllGroups(allGroups); + } + else { m->mothurOut("You have no current group file and the group parameter is required."); m->mothurOutEndLine(); abort = true; } + }else { + groupMap = new GroupMap(groupfile); + + int error = groupMap->readMap(); + if (error == 1) { abort = true; } + vector allGroups = groupMap->getNamesOfGroups(); + m->setAllGroups(allGroups); + m->setGroupFile(groupfile); + } + + string groups = validParameter.validFile(parameters, "groups", false); + if (groups == "not found") { groups = ""; } + else { + m->splitAtDash(groups, Groups); + m->setGroups(Groups); + } + + //check for optional parameter and set defaults + // ...at some point should added some additional type checking... + string label = validParameter.validFile(parameters, "label", false); + if (label == "not found") { label = ""; } + else { + if(label != "all") { m->splitAtDash(label, labels); allLines = 0; } + else { allLines = 1; } + } + } + + } + catch(exception& e) { + m->errorOut(e, "SharedCommand", "SharedCommand"); + exit(1); + } +} //********************************************************************************************************************** -SharedCommand::SharedCommand(){ +int SharedCommand::execute(){ try { - globaldata = GlobalData::getInstance(); + + if (abort == true) { if (calledHelp) { return 0; } return 2; } //getting output filename - filename = globaldata->inputFileName; - filename = getRootName(filename); + filename = listfile; + + if (outputDir == "") { outputDir += m->hasPath(filename); } + + filename = outputDir + m->getRootName(m->getSimpleName(filename)); filename = filename + "shared"; - openOutputFile(filename, out); - pickedGroups = false; + outputTypes["shared"].push_back(filename); - groupMap = globaldata->gGroupmap; + m->openOutputFile(filename, out); + pickedGroups = false; //if hte user has not specified any groups then use them all - if (globaldata->Groups.size() == 0) { - groups = groupMap->namesOfGroups; - }else{ //they have specified groups - groups = globaldata->Groups; - pickedGroups = true; - } + if (Groups.size() == 0) { + Groups = groupMap->getNamesOfGroups(); m->setGroups(Groups); + }else { pickedGroups = true; } //fill filehandles with neccessary ofstreams int i; ofstream* temp; - for (i=0; igetListFile()); + fileroot = outputDir + m->getRootName(m->getSimpleName(listfile)); //clears file before we start to write to it below - for (int i=0; imothurRemove((fileroot + Groups[i] + ".rabund")); + outputNames.push_back((fileroot + Groups[i] + ".rabund")); + outputTypes["rabund"].push_back((fileroot + Groups[i] + ".rabund")); } - - } - catch(exception& e) { - errorOut(e, "SharedCommand", "SharedCommand"); - exit(1); - } -} -//********************************************************************************************************************** - -int SharedCommand::execute(){ - try { //lookup.clear(); string errorOff = "no error"; //errorOff = ""; - - //read in listfile - read = new ReadOTUFile(globaldata->inputFileName); - read->read(&*globaldata); - delete read; - - input = globaldata->ginput; - SharedList = globaldata->gSharedList; + + //if user provided an order file containing the order the shared file should be in read it + if (ordergroupfile != "") { readOrderFile(); } + + input = new InputData(listfile, "shared"); + SharedList = input->getSharedListVector(); string lastLabel = SharedList->getLabel(); vector lookup; - if ((globaldata->Groups.size() == 0) && (SharedList->getNumSeqs() != groupMap->getNumSeqs())) { //if the user has not specified any groups and their files don't match exit with error - mothurOut("Your group file contains " + toString(groupMap->getNumSeqs()) + " sequences and list file contains " + toString(SharedList->getNumSeqs()) + " sequences. Please correct."); mothurOutEndLine(); + if (m->control_pressed) { + delete input; delete SharedList; delete groupMap; + for (it3 = filehandles.begin(); it3 != filehandles.end(); it3++) { delete it3->second; } + out.close(); m->mothurRemove(filename); + for (int i=0; imothurRemove((fileroot + Groups[i] + ".rabund")); } + return 0; + } + + //sanity check + int error = ListGroupSameSeqs(); + + if ((!pickedGroups) && (SharedList->getNumSeqs() != groupMap->getNumSeqs())) { //if the user has not specified any groups and their files don't match exit with error + m->mothurOut("Your group file contains " + toString(groupMap->getNumSeqs()) + " sequences and list file contains " + toString(SharedList->getNumSeqs()) + " sequences. Please correct."); m->mothurOutEndLine(); out.close(); - remove(filename.c_str()); //remove blank shared file you made + m->mothurRemove(filename); //remove blank shared file you made createMisMatchFile(); @@ -85,28 +261,34 @@ int SharedCommand::execute(){ for (it3 = filehandles.begin(); it3 != filehandles.end(); it3++) { delete it3->second; } - delete SharedList; - globaldata->gSharedList = NULL; + + delete input; delete SharedList; delete groupMap; - return 1; + return 0; } + if (error == 1) { m->control_pressed = true; } + //if user has specified groups make new groupfile for them - if (globaldata->Groups.size() != 0) { //make new group file + if (pickedGroups) { //make new group file string groups = ""; - for (int i = 0; i < globaldata->Groups.size(); i++) { - groups += globaldata->Groups[i] + "."; - } + if (m->getNumGroups() < 4) { + for (int i = 0; i < m->getNumGroups(); i++) { + groups += (m->getGroups())[i] + "."; + } + }else { groups = "merge"; } - string newGroupFile = getRootName(globaldata->inputFileName) + groups + "groups"; + string newGroupFile = outputDir + m->getRootName(m->getSimpleName(listfile)) + groups + "groups"; + outputTypes["group"].push_back(newGroupFile); + outputNames.push_back(newGroupFile); ofstream outGroups; - openOutputFile(newGroupFile, outGroups); + m->openOutputFile(newGroupFile, outGroups); vector names = groupMap->getNamesSeqs(); string groupName; for (int i = 0; i < names.size(); i++) { groupName = groupMap->getGroup(names[i]); - if (isValidGroup(groupName, globaldata->Groups)) { + if (isValidGroup(groupName, m->getGroups())) { outGroups << names[i] << '\t' << groupName << endl; } } @@ -115,18 +297,36 @@ int SharedCommand::execute(){ //if the users enters label "0.06" and there is no "0.06" in their file use the next lowest label. set processedLabels; - set userLabels = globaldata->labels; + set userLabels = labels; - while((SharedList != NULL) && ((globaldata->allLines == 1) || (userLabels.size() != 0))) { + while((SharedList != NULL) && ((allLines == 1) || (userLabels.size() != 0))) { + if (m->control_pressed) { + delete input; delete SharedList; delete groupMap; + for (it3 = filehandles.begin(); it3 != filehandles.end(); it3++) { delete it3->second; } + out.close(); m->mothurRemove(filename); + for (int i=0; imothurRemove((fileroot + Groups[i] + ".rabund")); } + return 0; + } - if(globaldata->allLines == 1 || globaldata->labels.count(SharedList->getLabel()) == 1){ - + if(allLines == 1 || labels.count(SharedList->getLabel()) == 1){ + lookup = SharedList->getSharedRAbundVector(); + + m->mothurOut(lookup[0]->getLabel()); m->mothurOutEndLine(); if (pickedGroups) { //check for otus with no seqs in them eliminateZeroOTUS(lookup); } - mothurOut(lookup[0]->getLabel()); mothurOutEndLine(); + if (m->control_pressed) { + delete input; delete SharedList; delete groupMap; + for (int i = 0; i < lookup.size(); i++) { delete lookup[i]; } + for (it3 = filehandles.begin(); it3 != filehandles.end(); it3++) { delete it3->second; } + out.close(); m->mothurRemove(filename); + for (int i=0; imothurRemove((fileroot + Groups[i] + ".rabund")); } + return 0; + } + + if (!m->printedHeaders) { lookup[0]->printHeaders(out); } printSharedData(lookup); //prints info to the .shared file for (int i = 0; i < lookup.size(); i++) { delete lookup[i]; } @@ -134,18 +334,29 @@ int SharedCommand::execute(){ userLabels.erase(SharedList->getLabel()); } - if ((anyLabelsToProcess(SharedList->getLabel(), userLabels, errorOff) == true) && (processedLabels.count(lastLabel) != 1)) { + if ((m->anyLabelsToProcess(SharedList->getLabel(), userLabels, errorOff) == true) && (processedLabels.count(lastLabel) != 1)) { string saveLabel = SharedList->getLabel(); delete SharedList; SharedList = input->getSharedListVector(lastLabel); //get new list vector to process lookup = SharedList->getSharedRAbundVector(); + m->mothurOut(lookup[0]->getLabel()); m->mothurOutEndLine(); if (pickedGroups) { //check for otus with no seqs in them eliminateZeroOTUS(lookup); } - mothurOut(lookup[0]->getLabel()); mothurOutEndLine(); + + if (m->control_pressed) { + delete input; delete SharedList; delete groupMap; + for (int i = 0; i < lookup.size(); i++) { delete lookup[i]; } + for (it3 = filehandles.begin(); it3 != filehandles.end(); it3++) { delete it3->second; } + out.close(); m->mothurRemove(filename); + for (int i=0; imothurRemove((fileroot + Groups[i] + ".rabund")); } + return 0; + } + + if (!m->printedHeaders) { lookup[0]->printHeaders(out); } printSharedData(lookup); //prints info to the .shared file for (int i = 0; i < lookup.size(); i++) { delete lookup[i]; } @@ -178,29 +389,66 @@ int SharedCommand::execute(){ SharedList = input->getSharedListVector(lastLabel); //get new list vector to process lookup = SharedList->getSharedRAbundVector(); + m->mothurOut(lookup[0]->getLabel()); m->mothurOutEndLine(); if (pickedGroups) { //check for otus with no seqs in them eliminateZeroOTUS(lookup); } - mothurOut(lookup[0]->getLabel()); mothurOutEndLine(); + if (m->control_pressed) { + delete input; delete groupMap; + for (it3 = filehandles.begin(); it3 != filehandles.end(); it3++) { delete it3->second; } + out.close(); m->mothurRemove(filename); + for (int i=0; imothurRemove((fileroot + Groups[i] + ".rabund")); } + return 0; + } + + if (!m->printedHeaders) { lookup[0]->printHeaders(out); } printSharedData(lookup); //prints info to the .shared file for (int i = 0; i < lookup.size(); i++) { delete lookup[i]; } delete SharedList; } - globaldata->gSharedList = NULL; - out.close(); for (it3 = filehandles.begin(); it3 != filehandles.end(); it3++) { delete it3->second; } + delete input; delete groupMap; + + if (m->control_pressed) { + m->mothurRemove(filename); + for (int i=0; imothurRemove((fileroot + Groups[i] + ".rabund")); } + return 0; + } + + //set rabund file as new current rabundfile + string current = ""; + itTypes = outputTypes.find("rabund"); + if (itTypes != outputTypes.end()) { + if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setRabundFile(current); } + } + + itTypes = outputTypes.find("shared"); + if (itTypes != outputTypes.end()) { + if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setSharedFile(current); } + } + + itTypes = outputTypes.find("group"); + if (itTypes != outputTypes.end()) { + if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setGroupFile(current); } + } + + m->mothurOutEndLine(); + m->mothurOut("Output File Names: "); m->mothurOutEndLine(); + for (int i = 0; i < outputNames.size(); i++) { m->mothurOut(outputNames[i]); m->mothurOutEndLine(); } + m->mothurOut(filename); m->mothurOutEndLine(); + m->mothurOutEndLine(); return 0; } catch(exception& e) { - errorOut(e, "SharedCommand", "execute"); + m->errorOut(e, "SharedCommand", "execute"); exit(1); } } @@ -208,26 +456,68 @@ int SharedCommand::execute(){ void SharedCommand::printSharedData(vector thislookup) { try { - //initialize bin values - for (int i = 0; i < thislookup.size(); i++) { -//cout << "in printData " << thislookup[i]->getLabel() << '\t' << thislookup[i]->getGroup() << endl; - out << thislookup[i]->getLabel() << '\t' << thislookup[i]->getGroup() << '\t'; - thislookup[i]->print(out); - - RAbundVector rav = thislookup[i]->getRAbundVector(); - openOutputFileAppend(fileroot + thislookup[i]->getGroup() + ".rabund", *(filehandles[thislookup[i]->getGroup()])); - rav.print(*(filehandles[thislookup[i]->getGroup()])); - (*(filehandles[thislookup[i]->getGroup()])).close(); + if (order.size() == 0) { //user has not specified an order so do aplabetically + sort(thislookup.begin(), thislookup.end(), compareSharedRabunds); + + m->clearGroups(); + vector Groups; + + //initialize bin values + for (int i = 0; i < thislookup.size(); i++) { + out << thislookup[i]->getLabel() << '\t' << thislookup[i]->getGroup() << '\t'; + thislookup[i]->print(out); + + Groups.push_back(thislookup[i]->getGroup()); + + RAbundVector rav = thislookup[i]->getRAbundVector(); + m->openOutputFileAppend(fileroot + thislookup[i]->getGroup() + ".rabund", *(filehandles[thislookup[i]->getGroup()])); + rav.print(*(filehandles[thislookup[i]->getGroup()])); + (*(filehandles[thislookup[i]->getGroup()])).close(); + } + m->setGroups(Groups); + }else{ + //create a map from groupName to each sharedrabund + map myMap; + map::iterator myIt; + + for (int i = 0; i < thislookup.size(); i++) { + myMap[thislookup[i]->getGroup()] = thislookup[i]; + } + + m->clearGroups(); + vector Groups; + + //loop through ordered list and print the rabund + for (int i = 0; i < order.size(); i++) { + myIt = myMap.find(order[i]); + + if(myIt != myMap.end()) { //we found it + out << (myIt->second)->getLabel() << '\t' << (myIt->second)->getGroup() << '\t'; + (myIt->second)->print(out); + + Groups.push_back((myIt->second)->getGroup()); + + RAbundVector rav = (myIt->second)->getRAbundVector(); + m->openOutputFileAppend(fileroot + (myIt->second)->getGroup() + ".rabund", *(filehandles[(myIt->second)->getGroup()])); + rav.print(*(filehandles[(myIt->second)->getGroup()])); + (*(filehandles[(myIt->second)->getGroup()])).close(); + }else{ + m->mothurOut("Can't find shared info for " + order[i] + ", skipping."); m->mothurOutEndLine(); + } + } + + m->setGroups(Groups); + } } catch(exception& e) { - errorOut(e, "SharedCommand", "printSharedData"); + m->errorOut(e, "SharedCommand", "printSharedData"); exit(1); } } //********************************************************************************************************************** -void SharedCommand::eliminateZeroOTUS(vector& thislookup) { +int SharedCommand::eliminateZeroOTUS(vector& thislookup) { try { vector newLookup; @@ -240,6 +530,7 @@ void SharedCommand::eliminateZeroOTUS(vector& thislookup) { //for each bin for (int i = 0; i < thislookup[0]->getNumBins(); i++) { + if (m->control_pressed) { for (int j = 0; j < newLookup.size(); j++) { delete newLookup[j]; } return 0; } //look at each sharedRabund and make sure they are not all zero bool allZero = true; @@ -252,35 +543,41 @@ void SharedCommand::eliminateZeroOTUS(vector& thislookup) { for (int j = 0; j < thislookup.size(); j++) { newLookup[j]->push_back(thislookup[j]->getAbundance(i), thislookup[j]->getGroup()); } + //if there is a bin label use it otherwise make one } //else{ cout << "bin # " << i << " is all zeros" << endl; } } for (int j = 0; j < thislookup.size(); j++) { delete thislookup[j]; } thislookup = newLookup; - + + return 0; } catch(exception& e) { - errorOut(e, "SharedCommand", "eliminateZeroOTUS"); + m->errorOut(e, "SharedCommand", "eliminateZeroOTUS"); exit(1); } } //********************************************************************************************************************** -void SharedCommand::createMisMatchFile() { +int SharedCommand::createMisMatchFile() { try { ofstream outMisMatch; - string outputMisMatchName = getRootName(globaldata->inputFileName); + string outputMisMatchName = outputDir + m->getRootName(m->getSimpleName(listfile)); //you have sequences in your list file that are not in your group file if (SharedList->getNumSeqs() > groupMap->getNumSeqs()) { outputMisMatchName += "missing.group"; - mothurOut("For a list of names that are in your list file and not in your group file, please refer to " + outputMisMatchName + "."); mothurOutEndLine(); + m->mothurOut("For a list of names that are in your list file and not in your group file, please refer to " + outputMisMatchName + "."); m->mothurOutEndLine(); + + m->openOutputFile(outputMisMatchName, outMisMatch); - openOutputFile(outputMisMatchName, outMisMatch); + map listNames; + map::iterator itList; //go through list and if group returns "not found" output it for (int i = 0; i < SharedList->getNumBins(); i++) { + if (m->control_pressed) { outMisMatch.close(); m->mothurRemove(outputMisMatchName); return 0; } string names = SharedList->get(i); @@ -288,13 +585,22 @@ void SharedCommand::createMisMatchFile() { string name = names.substr(0,names.find_first_of(',')); names = names.substr(names.find_first_of(',')+1, names.length()); string group = groupMap->getGroup(name); - cout << name << endl; + if(group == "not found") { outMisMatch << name << endl; } + + itList = listNames.find(name); + if (itList != listNames.end()) { m->mothurOut(name + " is in your list file more than once. Sequence names must be unique. please correct."); m->mothurOutEndLine(); } + else { listNames[name] = name; } } - cout << names << endl; + //get last name string group = groupMap->getGroup(names); - if(group == "not found") { outMisMatch << names << endl; } + if(group == "not found") { outMisMatch << names << endl; } + + itList = listNames.find(names); + if (itList != listNames.end()) { m->mothurOut(names + " is in your list file more than once. Sequence names must be unique. please correct."); m->mothurOutEndLine(); } + else { listNames[names] = names; } + } outMisMatch.close(); @@ -303,12 +609,15 @@ void SharedCommand::createMisMatchFile() { }else {//you have sequences in your group file that are not in you list file outputMisMatchName += "missing.name"; - mothurOut("For a list of names that are in your group file and not in your list file, please refer to " + outputMisMatchName + "."); mothurOutEndLine(); + m->mothurOut("For a list of names that are in your group file and not in your list file, please refer to " + outputMisMatchName + "."); m->mothurOutEndLine(); map namesInList; + map::iterator itList; //go through listfile and get names for (int i = 0; i < SharedList->getNumBins(); i++) { + if (m->control_pressed) { return 0; } + string names = SharedList->get(i); @@ -316,9 +625,16 @@ void SharedCommand::createMisMatchFile() { string name = names.substr(0,names.find_first_of(',')); names = names.substr(names.find_first_of(',')+1, names.length()); + itList = namesInList.find(name); + if (itList != namesInList.end()) { m->mothurOut(name + " is in your list file more than once. Sequence names must be unique. please correct."); m->mothurOutEndLine(); } + namesInList[name] = name; + } + itList = namesInList.find(names); + if (itList != namesInList.end()) { m->mothurOut(names + " is in your list file more than once. Sequence names must be unique. please correct."); m->mothurOutEndLine(); } + //get last name namesInList[names] = names; } @@ -328,10 +644,11 @@ void SharedCommand::createMisMatchFile() { map::iterator itMatch; - openOutputFile(outputMisMatchName, outMisMatch); + m->openOutputFile(outputMisMatchName, outMisMatch); //loop through names in seqNames and if they aren't in namesIn list output them for (int i = 0; i < seqNames.size(); i++) { + if (m->control_pressed) { outMisMatch.close(); m->mothurRemove(outputMisMatchName); return 0; } itMatch = namesInList.find(seqNames[i]); @@ -342,14 +659,57 @@ void SharedCommand::createMisMatchFile() { } outMisMatch.close(); } - + + return 0; } catch(exception& e) { - errorOut(e, "SharedCommand", "createMisMatchFile"); + m->errorOut(e, "SharedCommand", "createMisMatchFile"); + exit(1); + } +} +//********************************************************************************************************************** +int SharedCommand::ListGroupSameSeqs() { + try { + + int error = 0; + + vector groupMapsSeqs = groupMap->getNamesSeqs(); + + set groupNamesSeqs; + for(int i = 0; i < groupMapsSeqs.size(); i++) { + groupNamesSeqs.insert(groupMapsSeqs[i]); + } + + + //go through list and if group returns "not found" output it + for (int i = 0; i < SharedList->getNumBins(); i++) { + if (m->control_pressed) { return 0; } + + string names = SharedList->get(i); + + vector listNames; + m->splitAtComma(names, listNames); + + for (int j = 0; j < listNames.size(); j++) { + int num = groupNamesSeqs.count(listNames[j]); + + if (num == 0) { error = 1; m->mothurOut("[ERROR]: " + listNames[j] + " is in your listfile and not in your groupfile. Please correct."); m->mothurOutEndLine(); } + else { groupNamesSeqs.erase(listNames[j]); } + } + } + + for (set::iterator itGroupSet = groupNamesSeqs.begin(); itGroupSet != groupNamesSeqs.end(); itGroupSet++) { + error = 1; + m->mothurOut("[ERROR]: " + (*itGroupSet) + " is in your groupfile and not your listfile. Please correct."); m->mothurOutEndLine(); + } + + return error; + } + catch(exception& e) { + m->errorOut(e, "SharedCommand", "ListGroupSameSeqs"); exit(1); } } - //********************************************************************************************************************** SharedCommand::~SharedCommand(){ @@ -357,7 +717,32 @@ SharedCommand::~SharedCommand(){ } - +//********************************************************************************************************************** +int SharedCommand::readOrderFile() { + try { + //remove old names + order.clear(); + + ifstream in; + m->openInputFile(ordergroupfile, in); + string thisGroup; + + while(!in.eof()){ + in >> thisGroup; m->gobble(in); + + order.push_back(thisGroup); + + if (m->control_pressed) { order.clear(); break; } + } + in.close(); + + return 0; + } + catch(exception& e) { + m->errorOut(e, "SharedCommand", "readOrderFile"); + exit(1); + } +} //********************************************************************************************************************** bool SharedCommand::isValidGroup(string groupname, vector groups) { @@ -369,7 +754,7 @@ bool SharedCommand::isValidGroup(string groupname, vector groups) { return false; } catch(exception& e) { - errorOut(e, "SharedCommand", "isValidGroup"); + m->errorOut(e, "SharedCommand", "isValidGroup"); exit(1); } }