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