groupmap.cpp

   1 /*
   2  *  groupmap.cpp
   3  *  Dotur
   4  *
   5  *  Created by Sarah Westcott on 12/1/08.
   6  *  Copyright 2008 Schloss Lab UMASS Amherst. All rights reserved.
   7  *
   8  */
   9
  10 #include "groupmap.h"
  11
  12 /************************************************************/
  13
  14  GroupMap::GroupMap(string filename) {
  15         m = MothurOut::getInstance();
  16         groupFileName = filename;
  17         m->openInputFile(filename, fileHandle);
  18         index = 0;
  19 }
  20
  21 /************************************************************/
  22  GroupMap::~GroupMap(){}
  23
  24 /************************************************************/
  25 int GroupMap::readMap() {
  26     try {
  27         string seqName, seqGroup;
  28                 int error = 0;
  29         string rest = "";
  30         char buffer[4096];
  31         bool pairDone = false;
  32         bool columnOne = true;
  33
  34         while (!fileHandle.eof()) {
  35             if (m->control_pressed) { fileHandle.close();  return 1; }
  36
  37             fileHandle.read(buffer, 4096);
  38             vector<string> pieces = m->splitWhiteSpace(rest, buffer, fileHandle.gcount());
  39
  40             for (int i = 0; i < pieces.size(); i++) {
  41                 if (columnOne) {  seqName = pieces[i]; columnOne=false; }
  42                 else  { seqGroup = pieces[i]; pairDone = true; columnOne=true; }
  43
  44                 if (pairDone) {
  45                     setNamesOfGroups(seqGroup);
  46
  47                     if (m->debug) { m->mothurOut("[DEBUG]: name = '" + seqName + "', group = '" + seqGroup + "'\n"); }
  48                     it = groupmap.find(seqName);
  49
  50                     if (it != groupmap.end()) { error = 1; m->mothurOut("Your groupfile contains more than 1 sequence named " + seqName + ", sequence names must be unique. Please correct."); m->mothurOutEndLine();  }
  51                     else {
  52                         groupmap[seqName] = seqGroup;   //store data in map
  53                         seqsPerGroup[seqGroup]++;  //increment number of seqs in that group
  54                     }
  55                     pairDone = false;
  56                 }
  57             }
  58         }
  59                 fileHandle.close();
  60
  61         if (rest != "") {
  62             vector<string> pieces = m->splitWhiteSpace(rest);
  63
  64             for (int i = 0; i < pieces.size(); i++) {
  65                 if (columnOne) {  seqName = pieces[i]; columnOne=false; }
  66                 else  { seqGroup = pieces[i]; pairDone = true; columnOne=true; }
  67
  68                 if (pairDone) {
  69                     setNamesOfGroups(seqGroup);
  70
  71                     if (m->debug) { m->mothurOut("[DEBUG]: name = '" + seqName + "', group = '" + seqGroup + "'\n"); }
  72
  73                     it = groupmap.find(seqName);
  74
  75                     if (it != groupmap.end()) { error = 1; m->mothurOut("Your groupfile contains more than 1 sequence named " + seqName + ", sequence names must be unique. Please correct."); m->mothurOutEndLine();  }
  76                     else {
  77                         groupmap[seqName] = seqGroup;   //store data in map
  78                         seqsPerGroup[seqGroup]++;  //increment number of seqs in that group
  79                     }
  80                     pairDone = false;
  81                 }
  82             }
  83         }
  84
  85                 m->setAllGroups(namesOfGroups);
  86                 return error;
  87     }
  88         catch(exception& e) {
  89                 m->errorOut(e, "GroupMap", "readMap");
  90                 exit(1);
  91         }
  92 }
  93 /************************************************************/
  94 int GroupMap::readDesignMap() {
  95     try {
  96         string seqName, seqGroup;
  97                 int error = 0;
  98         string rest = "";
  99         char buffer[4096];
 100         bool pairDone = false;
 101         bool columnOne = true;
 102
 103         while (!fileHandle.eof()) {
 104             if (m->control_pressed) { fileHandle.close();  return 1; }
 105
 106             fileHandle.read(buffer, 4096);
 107             vector<string> pieces = m->splitWhiteSpace(rest, buffer, fileHandle.gcount());
 108
 109             for (int i = 0; i < pieces.size(); i++) {
 110                 if (columnOne) {  seqName = pieces[i]; columnOne=false; }
 111                 else  { seqGroup = pieces[i]; pairDone = true; columnOne=true; }
 112
 113                 if (pairDone) {
 114                     setNamesOfGroups(seqGroup);
 115
 116                     if (m->debug) { m->mothurOut("[DEBUG]: name = '" + seqName + "', group = '" + seqGroup + "'\n"); }
 117
 118                     it = groupmap.find(seqName);
 119
 120                     if (it != groupmap.end()) { error = 1; m->mothurOut("Your designfile contains more than 1 sequence named " + seqName + ", sequence names must be unique. Please correct."); m->mothurOutEndLine();  }
 121                     else {
 122                         groupmap[seqName] = seqGroup;   //store data in map
 123                         seqsPerGroup[seqGroup]++;  //increment number of seqs in that group
 124                     }
 125                     pairDone = false;
 126                 }
 127             }
 128         }
 129                 fileHandle.close();
 130
 131         if (rest != "") {
 132             vector<string> pieces = m->splitWhiteSpace(rest);
 133
 134             for (int i = 0; i < pieces.size(); i++) {
 135                 if (columnOne) {  seqName = pieces[i]; columnOne=false; }
 136                 else  { seqGroup = pieces[i]; pairDone = true; columnOne=true; }
 137
 138                 if (pairDone) {
 139                     setNamesOfGroups(seqGroup);
 140
 141                     if (m->debug) { m->mothurOut("[DEBUG]: name = '" + seqName + "', group = '" + seqGroup + "'\n"); }
 142
 143                     it = groupmap.find(seqName);
 144
 145                     if (it != groupmap.end()) { error = 1; m->mothurOut("Your designfile contains more than 1 sequence named " + seqName + ", sequence names must be unique. Please correct."); m->mothurOutEndLine();  }
 146                     else {
 147                         groupmap[seqName] = seqGroup;   //store data in map
 148                         seqsPerGroup[seqGroup]++;  //increment number of seqs in that group
 149                     }
 150                     pairDone = false;
 151                 }
 152             }
 153
 154         }
 155
 156                 m->setAllGroups(namesOfGroups);
 157                 return error;
 158     }
 159         catch(exception& e) {
 160                 m->errorOut(e, "GroupMap", "readDesignMap");
 161                 exit(1);
 162         }
 163 }
 164 /************************************************************/
 165 int GroupMap::readDesignMap(string filename) {
 166     try {
 167         groupFileName = filename;
 168         m->openInputFile(filename, fileHandle);
 169         index = 0;
 170         string seqName, seqGroup;
 171                 int error = 0;
 172         string rest = "";
 173         char buffer[4096];
 174         bool pairDone = false;
 175         bool columnOne = true;
 176
 177         while (!fileHandle.eof()) {
 178             if (m->control_pressed) { fileHandle.close();  return 1; }
 179
 180             fileHandle.read(buffer, 4096);
 181             vector<string> pieces = m->splitWhiteSpace(rest, buffer, fileHandle.gcount());
 182
 183             for (int i = 0; i < pieces.size(); i++) {
 184                 if (columnOne) {  seqName = pieces[i]; columnOne=false; }
 185                 else  { seqGroup = pieces[i]; pairDone = true; columnOne=true; }
 186
 187                 if (pairDone) {
 188                     setNamesOfGroups(seqGroup);
 189
 190                     if (m->debug) { m->mothurOut("[DEBUG]: name = '" + seqName + "', group = '" + seqGroup + "'\n"); }
 191
 192                     it = groupmap.find(seqName);
 193
 194                     if (it != groupmap.end()) { error = 1; m->mothurOut("Your designfile contains more than 1 sequence named " + seqName + ", sequence names must be unique. Please correct."); m->mothurOutEndLine();  }
 195                     else {
 196                         groupmap[seqName] = seqGroup;   //store data in map
 197                         seqsPerGroup[seqGroup]++;  //increment number of seqs in that group
 198                     }
 199                     pairDone = false;
 200                 }
 201             }
 202         }
 203                 fileHandle.close();
 204
 205         if (rest != "") {
 206             vector<string> pieces = m->splitWhiteSpace(rest);
 207
 208             for (int i = 0; i < pieces.size(); i++) {
 209                 if (columnOne) {  seqName = pieces[i]; columnOne=false; }
 210                 else  { seqGroup = pieces[i]; pairDone = true; columnOne=true; }
 211
 212                 if (pairDone) {
 213                     setNamesOfGroups(seqGroup);
 214
 215                     if (m->debug) { m->mothurOut("[DEBUG]: name = '" + seqName + "', group = '" + seqGroup + "'\n"); }
 216
 217                     it = groupmap.find(seqName);
 218
 219                     if (it != groupmap.end()) { error = 1; m->mothurOut("Your designfile contains more than 1 sequence named " + seqName + ", sequence names must be unique. Please correct."); m->mothurOutEndLine();  }
 220                     else {
 221                         groupmap[seqName] = seqGroup;   //store data in map
 222                         seqsPerGroup[seqGroup]++;  //increment number of seqs in that group
 223                     }
 224                     pairDone = false;
 225                 }
 226             }
 227         }
 228
 229                 m->setAllGroups(namesOfGroups);
 230                 return error;
 231     }
 232         catch(exception& e) {
 233                 m->errorOut(e, "GroupMap", "readDesignMap");
 234                 exit(1);
 235         }
 236 }
 237 /************************************************************/
 238 int GroupMap::getNumGroups() { return namesOfGroups.size();     }
 239 /************************************************************/
 240
 241 string GroupMap::getGroup(string sequenceName) {
 242
 243         it = groupmap.find(sequenceName);
 244         if (it != groupmap.end()) { //sequence name was in group file
 245                 return it->second;
 246         }else {
 247                 return "not found";
 248         }
 249 }
 250
 251 /************************************************************/
 252
 253 void GroupMap::setGroup(string sequenceName, string groupN) {
 254         setNamesOfGroups(groupN);
 255
 256         it = groupmap.find(sequenceName);
 257
 258         if (it != groupmap.end()) {  m->mothurOut("Your groupfile contains more than 1 sequence named " + sequenceName + ", sequence names must be unique. Please correct."); m->mothurOutEndLine();  }
 259         else {
 260                 groupmap[sequenceName] = groupN;        //store data in map
 261                 seqsPerGroup[groupN]++;  //increment number of seqs in that group
 262         }
 263 }
 264
 265 /************************************************************/
 266 void GroupMap::setNamesOfGroups(string seqGroup) {
 267         int i, count;
 268         count = 0;
 269         for (i=0; i<namesOfGroups.size(); i++) {
 270                 if (namesOfGroups[i] != seqGroup) {
 271                         count++; //you have not found this group
 272                 }else {
 273                         break; //you already have it
 274                 }
 275         }
 276         if (count == namesOfGroups.size()) {
 277                 namesOfGroups.push_back(seqGroup); //new group
 278                 seqsPerGroup[seqGroup] = 0;
 279                 groupIndex[seqGroup] = index;
 280                 index++;
 281         }
 282 }
 283 /************************************************************/
 284 bool GroupMap::isValidGroup(string groupname) {
 285         try {
 286                 for (int i = 0; i < namesOfGroups.size(); i++) {
 287                         if (groupname == namesOfGroups[i]) { return true; }
 288                 }
 289
 290                 return false;
 291         }
 292         catch(exception& e) {
 293                 m->errorOut(e, "GroupMap", "isValidGroup");
 294                 exit(1);
 295         }
 296 }
 297 /************************************************************/
 298 int GroupMap::getNumSeqs(string group) {
 299         try {
 300
 301                 map<string, int>::iterator itNum;
 302
 303                 itNum = seqsPerGroup.find(group);
 304
 305                 if (itNum == seqsPerGroup.end()) { return 0; }
 306
 307                 return seqsPerGroup[group];
 308
 309         }
 310         catch(exception& e) {
 311                 m->errorOut(e, "GroupMap", "getNumSeqs");
 312                 exit(1);
 313         }
 314 }
 315
 316 /************************************************************/
 317 vector<string> GroupMap::getNamesSeqs(){
 318         try {
 319
 320                 vector<string> names;
 321
 322                 for (it = groupmap.begin(); it != groupmap.end(); it++) {
 323                         names.push_back(it->first);
 324                 }
 325
 326                 return names;
 327         }
 328         catch(exception& e) {
 329                 m->errorOut(e, "GroupMap", "getNamesSeqs");
 330                 exit(1);
 331         }
 332 }
 333 /************************************************************/
 334 vector<string> GroupMap::getNamesSeqs(vector<string> picked){
 335         try {
 336
 337                 vector<string> names;
 338
 339                 for (it = groupmap.begin(); it != groupmap.end(); it++) {
 340                         //if you are belong to one the the groups in the picked vector add you
 341                         if (m->inUsersGroups(it->second, picked)) {
 342                                 names.push_back(it->first);
 343                         }
 344                 }
 345
 346                 return names;
 347         }
 348         catch(exception& e) {
 349                 m->errorOut(e, "GroupMap", "getNamesSeqs");
 350                 exit(1);
 351         }
 352 }
 353
 354 /************************************************************/
 355