fileoutput.cpp

   1 /*
   2  *  fileoutput.cpp
   3  *  Dotur
   4  *
   5  *  Created by Sarah Westcott on 11/18/08.
   6  *  Copyright 2008 Schloss Lab UMASS Amherst. All rights reserved.
   7  *
   8  */
   9
  10 #include "fileoutput.h"
  11
  12 /***********************************************************************/
  13
  14 ThreeColumnFile::~ThreeColumnFile(){
  15
  16         inFile.close();
  17         outFile.close();
  18         remove(outName.c_str());
  19 }
  20
  21 /***********************************************************************/
  22
  23 void ThreeColumnFile::initFile(string label){
  24         try {
  25                 if(counter != 0){
  26                         openOutputFile(outName, outFile);
  27                         openInputFile(inName, inFile);
  28
  29                         string inputBuffer;
  30                         inputBuffer = getline(inFile);
  31
  32                         outFile <<  inputBuffer << '\t' << label << "\tlci\thci" << endl;
  33                 }
  34                 else{
  35                         openOutputFile(outName, outFile);
  36                         outFile << "numsampled\t" << label << "\tlci\thci" << endl;
  37                 }
  38
  39                 outFile.setf(ios::fixed, ios::floatfield);
  40                 outFile.setf(ios::showpoint);
  41         }
  42         catch(exception& e) {
  43                 errorOut(e, "ThreeColumnFile", "initFile");
  44                 exit(1);
  45         }
  46 }
  47
  48 /***********************************************************************/
  49
  50 void ThreeColumnFile::output(int nSeqs, vector<double> data){
  51         try {
  52                 if(counter != 0){
  53                         string inputBuffer;
  54                         inputBuffer = getline(inFile);
  55
  56                         outFile <<  inputBuffer << setprecision(4) << '\t' << data[0] << '\t' << data[1] << '\t' << data[2] << endl;
  57                 }
  58                 else{
  59                         outFile << nSeqs << setprecision(4) << '\t' << data[0] << '\t' << data[1] << '\t' << data[2] << endl;
  60                 }
  61         }
  62         catch(exception& e) {
  63                 errorOut(e, "ThreeColumnFile", "output");
  64                 exit(1);
  65         }
  66 }
  67
  68 /***********************************************************************/
  69
  70 void ThreeColumnFile::resetFile(){
  71         try {
  72                 if(counter != 0){
  73                         outFile.close();
  74                         inFile.close();
  75                 }
  76                 else{
  77                         outFile.close();
  78                 }
  79                 counter = 1;
  80
  81                 remove(inName.c_str());
  82                 renameOk = rename(outName.c_str(), inName.c_str());
  83
  84                 //checks to make sure user was able to rename and remove successfully
  85                 if ((renameOk != 0)) {  mothurOut("Unable to rename necessary files."); mothurOutEndLine(); }
  86
  87         }
  88         catch(exception& e) {
  89                 errorOut(e, "ThreeColumnFile", "resetFile");
  90                 exit(1);
  91         }
  92 }
  93
  94 /***********************************************************************/
  95 /***********************************************************************/
  96
  97 ColumnFile::~ColumnFile(){
  98
  99         inFile.close();
 100         outFile.close();
 101         remove(outName.c_str());
 102 }
 103
 104 /***********************************************************************/
 105
 106 void ColumnFile::initFile(string label, vector<string> tags){
 107         try {
 108                 if(counter != 0){
 109                         openOutputFile(outName, outFile);
 110                         openInputFile(inName, inFile);
 111
 112                         string inputBuffer;
 113                         inputBuffer = getline(inFile);
 114
 115                         outFile <<  inputBuffer << '\t';
 116                         for(int i = 0; i < tags.size(); i++) {
 117                                 outFile << label + tags[i] << '\t';
 118                         }
 119                         outFile << endl;
 120                 }
 121                 else{
 122                         openOutputFile(outName, outFile);
 123                         for(int i = 0; i < tags.size(); i++) {
 124                                 outFile << label + tags[i] << '\t';
 125                         }
 126                         outFile << endl;
 127                 }
 128
 129                 outFile.setf(ios::fixed, ios::floatfield);
 130                 outFile.setf(ios::showpoint);
 131         }
 132         catch(exception& e) {
 133                 errorOut(e, "ColumnFile", "initFile");
 134                 exit(1);
 135         }
 136 }
 137
 138 /***********************************************************************/
 139
 140 void ColumnFile::output(vector<double> data){
 141         try {
 142
 143                 if(counter != 0){
 144                         string inputBuffer;
 145                         inputBuffer = getline(inFile);
 146
 147                         outFile << inputBuffer << '\t' << setprecision(6) << data[0] << setprecision(iters.length());
 148                         for (int i = 1; i< data.size(); i++) {
 149                                 outFile << '\t' << data[i];
 150                         }
 151                         outFile << endl;
 152                 }
 153                 else{
 154                         outFile << setprecision(6) << data[0] << setprecision(iters.length());
 155                         for (int i = 1; i< data.size(); i++) {
 156                                 outFile << '\t' << data[i];
 157                         }
 158                         outFile << endl;
 159                 }
 160
 161         }
 162         catch(exception& e) {
 163                 errorOut(e, "ColumnFile", "output");
 164                 exit(1);
 165         }
 166 }
 167
 168 /***********************************************************************/
 169
 170 void ColumnFile::resetFile(){
 171         try {
 172                 if(counter != 0){
 173                         outFile.close();
 174                         inFile.close();
 175                 }
 176                 else{
 177                         outFile.close();
 178                 }
 179                 counter = 1;
 180
 181                 remove(inName.c_str());
 182                 renameOk = rename(outName.c_str(), inName.c_str());
 183
 184                 //checks to make sure user was able to rename and remove successfully
 185                 if ((renameOk != 0)) { mothurOut("Unable to rename necessary files."); mothurOutEndLine(); }
 186
 187         }
 188         catch(exception& e) {
 189                 errorOut(e, "ColumnFile", "resetFile");
 190                 exit(1);
 191         }
 192 }
 193
 194 /***********************************************************************/
 195 /***********************************************************************/
 196
 197 SharedThreeColumnFile::~SharedThreeColumnFile(){
 198
 199         inFile.close();
 200         outFile.close();
 201         remove(outName.c_str());
 202 }
 203
 204 /***********************************************************************/
 205
 206 void SharedThreeColumnFile::initFile(string label){
 207         try {
 208                 if(counter != 0){
 209                         openOutputFile(outName, outFile);
 210                         openInputFile(inName, inFile);
 211
 212                         string inputBuffer;
 213                         inputBuffer = getline(inFile);
 214
 215                         outFile <<  inputBuffer << '\t' << label << "\tlci\thci" << endl;
 216                 }
 217                 else{
 218                         openOutputFile(outName, outFile);
 219                         outFile << "numsampled\t" << groupLabel << '\t' << label << "\tlci\thci" << endl;
 220                 }
 221
 222                 outFile.setf(ios::fixed, ios::floatfield);
 223                 outFile.setf(ios::showpoint);
 224         }
 225         catch(exception& e) {
 226                 errorOut(e, "SharedThreeColumnFile", "initFile");
 227                 exit(1);
 228         }
 229 }
 230
 231 /***********************************************************************/
 232
 233 void SharedThreeColumnFile::output(int nSeqs, vector<double> data){
 234         try {
 235                 if(counter != 0){
 236                         string inputBuffer;
 237                         inputBuffer = getline(inFile);
 238
 239                         outFile <<  inputBuffer << setprecision(4) << '\t' << data[0] << '\t' << data[1] << '\t' << data[2] << endl;
 240                 }
 241                 else{
 242                         outFile << numGroup << setprecision(4) << '\t' << data[0] << '\t' << data[1] << '\t' << data[2] << endl;
 243                         numGroup++;
 244                 }
 245         }
 246         catch(exception& e) {
 247                 errorOut(e, "SharedThreeColumnFile", "output");
 248                 exit(1);
 249         }
 250 }
 251
 252 /***********************************************************************/
 253
 254 void SharedThreeColumnFile::resetFile(){
 255         try {
 256                 if(counter != 0){
 257                         outFile.close();
 258                         inFile.close();
 259                 }
 260                 else{
 261                         outFile.close();
 262                 }
 263                 counter = 1;
 264                 remove(inName.c_str());
 265                 renameOk = rename(outName.c_str(), inName.c_str());
 266
 267                 //checks to make sure user was able to rename and remove successfully
 268                 if ((renameOk != 0)) { mothurOut("Unable to rename necessary files."); mothurOutEndLine(); }
 269
 270         }
 271         catch(exception& e) {
 272                 errorOut(e, "SharedThreeColumnFile", "resetFile");
 273                 exit(1);
 274         }
 275 }
 276
 277 /***********************************************************************/
 278
 279 /***********************************************************************/
 280
 281 OneColumnFile::~OneColumnFile(){
 282
 283         inFile.close();
 284         outFile.close();
 285         remove(outName.c_str());
 286 }
 287
 288 /***********************************************************************/
 289
 290 void OneColumnFile::initFile(string label){
 291         try {
 292                 if(counter != 0){
 293                         openOutputFile(outName, outFile);
 294                         openInputFile(inName, inFile);
 295
 296                         string inputBuffer;
 297                         inputBuffer = getline(inFile);
 298
 299                         outFile <<  inputBuffer << '\t' << label << endl;
 300                 }
 301                 else{
 302                         openOutputFile(outName, outFile);
 303                         outFile << "numsequences\t" << label << endl;
 304                 }
 305
 306                 outFile.setf(ios::fixed, ios::floatfield);
 307                 outFile.setf(ios::showpoint);
 308         }
 309         catch(exception& e) {
 310                 errorOut(e, "OneColumnFile", "initFile");
 311                 exit(1);
 312         }
 313 }
 314
 315 /***********************************************************************/
 316
 317 void OneColumnFile::output(int nSeqs, vector<double> data){
 318         try {
 319                 if(counter != 0){
 320                         string inputBuffer;
 321                         inputBuffer = getline(inFile);
 322
 323                         outFile <<  inputBuffer << setprecision(4) << '\t'  << data[0] << endl;
 324                 }
 325                 else{
 326                         outFile << nSeqs << setprecision(4) << '\t' << data[0] << endl;
 327                 }
 328         }
 329         catch(exception& e) {
 330                 errorOut(e, "OneColumnFile", "output");
 331                 exit(1);
 332         }
 333 }
 334
 335 /***********************************************************************/
 336
 337 void OneColumnFile::resetFile(){
 338         try {
 339                 if(counter != 0){
 340                         outFile.close();
 341                         inFile.close();
 342                 }
 343                 else{
 344                         outFile.close();
 345                 }
 346                 counter = 1;
 347                 remove(inName.c_str());
 348                 renameOk = rename(outName.c_str(), inName.c_str());
 349
 350                 //checks to make sure user was able to rename and remove successfully
 351                 if ((renameOk != 0)) { mothurOut("Unable to rename necessary files."); mothurOutEndLine(); }
 352
 353         }
 354         catch(exception& e) {
 355                 errorOut(e, "OneColumnFile", "resetFile");
 356                 exit(1);
 357         }
 358 }
 359
 360 /***********************************************************************/
 361 /***********************************************************************/
 362
 363 SharedOneColumnFile::~SharedOneColumnFile(){
 364
 365         inFile.close();
 366         outFile.close();
 367         remove(outName.c_str());
 368 }
 369
 370 /***********************************************************************/
 371
 372 void SharedOneColumnFile::initFile(string label){
 373         try {
 374                 if(counter != 0){
 375                         openOutputFile(outName, outFile);
 376                         openInputFile(inName, inFile);
 377
 378                         string inputBuffer;
 379                         inputBuffer = getline(inFile);
 380
 381                         outFile <<  inputBuffer << '\t' << label  << endl;
 382
 383                 }
 384                 else{
 385                         openOutputFile(outName, outFile);
 386                         outFile << "sampled\t" << label << endl;
 387
 388                 }
 389
 390                 outFile.setf(ios::fixed, ios::floatfield);
 391                 outFile.setf(ios::showpoint);
 392         }
 393         catch(exception& e) {
 394                 errorOut(e, "SharedOneColumnFile", "initFile");
 395                 exit(1);
 396         }
 397 }
 398
 399 /***********************************************************************/
 400
 401 void SharedOneColumnFile::output(int nSeqs, vector<double> data){
 402         try {
 403                         string dataOutput;
 404                         float sam;
 405                         sam = data[0];
 406                         dataOutput = "";
 407                         for (int i = 0; i < data.size(); i++) {
 408                                 dataOutput = dataOutput + "\t" + toString(data[i]);
 409                         }
 410                         if(counter != 0){
 411                                 string inputBuffer;
 412                                 inputBuffer = getline(inFile);
 413
 414                                 outFile <<  inputBuffer << setprecision(2) << '\t' << dataOutput << endl;
 415                         }
 416                         else{
 417                                 outFile << nSeqs << setprecision(2) << '\t' << dataOutput << endl;
 418                         }
 419         }
 420         catch(exception& e) {
 421                 errorOut(e, "SharedOneColumnFile", "output");
 422                 exit(1);
 423         }
 424 }
 425
 426 /***********************************************************************/
 427
 428 void SharedOneColumnFile::resetFile(){
 429         try {
 430                 if(counter != 0){
 431                         outFile.close();
 432                         inFile.close();
 433                 }
 434                 else{
 435                         outFile.close();
 436                 }
 437                 counter = 1;
 438
 439                 remove(inName.c_str());
 440                 renameOk = rename(outName.c_str(), inName.c_str());
 441
 442                 //checks to make sure user was able to rename and remove successfully
 443                 if ((renameOk != 0)) { mothurOut("Unable to rename necessary files."); mothurOutEndLine(); }
 444
 445
 446         }
 447         catch(exception& e) {
 448                 errorOut(e, "SharedOneColumnFile", "resetFile");
 449                 exit(1);
 450         }
 451 }
 452
 453 /***********************************************************************/