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)) {
  86                         mothurOut("Unable to rename " + outName); mothurOutEndLine();
  87                         perror(" : ");
  88                 }
  89         }
  90         catch(exception& e) {
  91                 errorOut(e, "ThreeColumnFile", "resetFile");
  92                 exit(1);
  93         }
  94 }
  95
  96 /***********************************************************************/
  97 /***********************************************************************/
  98
  99 ColumnFile::~ColumnFile(){
 100
 101         inFile.close();
 102         outFile.close();
 103         remove(outName.c_str());
 104 }
 105
 106 /***********************************************************************/
 107
 108 void ColumnFile::initFile(string label, vector<string> tags){
 109         try {
 110                 if(counter != 0){
 111                         openOutputFile(outName, outFile);
 112                         openInputFile(inName, inFile);
 113
 114                         string inputBuffer;
 115                         inputBuffer = getline(inFile);
 116
 117                         outFile <<  inputBuffer << '\t';
 118                         for(int i = 0; i < tags.size(); i++) {
 119                                 outFile << label + tags[i] << '\t';
 120                         }
 121                         outFile << endl;
 122                 }
 123                 else{
 124                         openOutputFile(outName, outFile);
 125                         for(int i = 0; i < tags.size(); i++) {
 126                                 outFile << label + tags[i] << '\t';
 127                         }
 128                         outFile << endl;
 129                 }
 130
 131                 outFile.setf(ios::fixed, ios::floatfield);
 132                 outFile.setf(ios::showpoint);
 133         }
 134         catch(exception& e) {
 135                 errorOut(e, "ColumnFile", "initFile");
 136                 exit(1);
 137         }
 138 }
 139
 140 /***********************************************************************/
 141
 142 void ColumnFile::output(vector<double> data){
 143         try {
 144
 145                 if(counter != 0){
 146                         string inputBuffer;
 147                         inputBuffer = getline(inFile);
 148
 149                         outFile << inputBuffer << '\t' << setprecision(6) << data[0] << setprecision(iters.length());
 150                         for (int i = 1; i< data.size(); i++) {
 151                                 outFile << '\t' << data[i];
 152                         }
 153                         outFile << endl;
 154                 }
 155                 else{
 156                         outFile << setprecision(6) << data[0] << setprecision(iters.length());
 157                         for (int i = 1; i< data.size(); i++) {
 158                                 outFile << '\t' << data[i];
 159                         }
 160                         outFile << endl;
 161                 }
 162
 163         }
 164         catch(exception& e) {
 165                 errorOut(e, "ColumnFile", "output");
 166                 exit(1);
 167         }
 168 }
 169
 170 /***********************************************************************/
 171
 172 void ColumnFile::resetFile(){
 173         try {
 174                 if(counter != 0){
 175                         outFile.close();
 176                         inFile.close();
 177                 }
 178                 else{
 179                         outFile.close();
 180                 }
 181                 counter = 1;
 182
 183                 remove(inName.c_str());
 184                 renameOk = rename(outName.c_str(), inName.c_str());
 185
 186                 //checks to make sure user was able to rename and remove successfully
 187                 if ((renameOk != 0)) {
 188                         mothurOut("Unable to rename " + outName); mothurOutEndLine();
 189                         perror(" : ");
 190                 }
 191         }
 192         catch(exception& e) {
 193                 errorOut(e, "ColumnFile", "resetFile");
 194                 exit(1);
 195         }
 196 }
 197
 198 /***********************************************************************/
 199 /***********************************************************************/
 200
 201 SharedThreeColumnFile::~SharedThreeColumnFile(){
 202
 203         inFile.close();
 204         outFile.close();
 205         remove(outName.c_str());
 206 }
 207
 208 /***********************************************************************/
 209
 210 void SharedThreeColumnFile::initFile(string label){
 211         try {
 212                 if(counter != 0){
 213                         openOutputFile(outName, outFile);
 214                         openInputFile(inName, inFile);
 215
 216                         string inputBuffer;
 217                         inputBuffer = getline(inFile);
 218
 219                         outFile <<  inputBuffer << '\t' << label << "\tlci\thci" << endl;
 220                 }
 221                 else{
 222                         openOutputFile(outName, outFile);
 223                         outFile << "numsampled\t" << groupLabel << '\t' << label << "\tlci\thci" << endl;
 224                 }
 225
 226                 outFile.setf(ios::fixed, ios::floatfield);
 227                 outFile.setf(ios::showpoint);
 228         }
 229         catch(exception& e) {
 230                 errorOut(e, "SharedThreeColumnFile", "initFile");
 231                 exit(1);
 232         }
 233 }
 234
 235 /***********************************************************************/
 236
 237 void SharedThreeColumnFile::output(int nSeqs, vector<double> data){
 238         try {
 239                 if(counter != 0){
 240                         string inputBuffer;
 241                         inputBuffer = getline(inFile);
 242
 243                         outFile <<  inputBuffer << setprecision(4) << '\t' << data[0] << '\t' << data[1] << '\t' << data[2] << endl;
 244                 }
 245                 else{
 246                         outFile << numGroup << setprecision(4) << '\t' << data[0] << '\t' << data[1] << '\t' << data[2] << endl;
 247                         numGroup++;
 248                 }
 249         }
 250         catch(exception& e) {
 251                 errorOut(e, "SharedThreeColumnFile", "output");
 252                 exit(1);
 253         }
 254 }
 255
 256 /***********************************************************************/
 257
 258 void SharedThreeColumnFile::resetFile(){
 259         try {
 260                 if(counter != 0){
 261                         outFile.close();
 262                         inFile.close();
 263                 }
 264                 else{
 265                         outFile.close();
 266                 }
 267                 counter = 1;
 268                 remove(inName.c_str());
 269                 renameOk = rename(outName.c_str(), inName.c_str());
 270
 271                 //checks to make sure user was able to rename and remove successfully
 272                 if ((renameOk != 0)) {
 273                         mothurOut("Unable to rename " + outName); mothurOutEndLine();
 274                         perror(" : ");
 275                 }
 276         }
 277         catch(exception& e) {
 278                 errorOut(e, "SharedThreeColumnFile", "resetFile");
 279                 exit(1);
 280         }
 281 }
 282
 283 /***********************************************************************/
 284
 285 /***********************************************************************/
 286
 287 OneColumnFile::~OneColumnFile(){
 288
 289         inFile.close();
 290         outFile.close();
 291         remove(outName.c_str());
 292 }
 293
 294 /***********************************************************************/
 295
 296 void OneColumnFile::initFile(string label){
 297         try {
 298                 if(counter != 0){
 299                         openOutputFile(outName, outFile);
 300                         openInputFile(inName, inFile);
 301
 302                         string inputBuffer;
 303                         inputBuffer = getline(inFile);
 304
 305                         outFile <<  inputBuffer << '\t' << label << endl;
 306                 }
 307                 else{
 308                         openOutputFile(outName, outFile);
 309                         outFile << "numsampled\t" << label << endl;
 310                 }
 311
 312                 outFile.setf(ios::fixed, ios::floatfield);
 313                 outFile.setf(ios::showpoint);
 314         }
 315         catch(exception& e) {
 316                 errorOut(e, "OneColumnFile", "initFile");
 317                 exit(1);
 318         }
 319 }
 320
 321 /***********************************************************************/
 322
 323 void OneColumnFile::output(int nSeqs, vector<double> data){
 324         try {
 325                 if(counter != 0){
 326                         string inputBuffer;
 327                         inputBuffer = getline(inFile);
 328
 329                         outFile <<  inputBuffer << setprecision(4) << '\t'  << data[0] << endl;
 330                 }
 331                 else{
 332                         outFile << nSeqs << setprecision(4) << '\t' << data[0] << endl;
 333                 }
 334         }
 335         catch(exception& e) {
 336                 errorOut(e, "OneColumnFile", "output");
 337                 exit(1);
 338         }
 339 }
 340
 341 /***********************************************************************/
 342
 343 void OneColumnFile::resetFile(){
 344         try {
 345                 if(counter != 0){
 346                         outFile.close();
 347                         inFile.close();
 348                 }
 349                 else{
 350                         outFile.close();
 351                 }
 352                 counter = 1;
 353                 remove(inName.c_str());
 354                 renameOk = rename(outName.c_str(), inName.c_str());
 355
 356                 //checks to make sure user was able to rename and remove successfully
 357                 if ((renameOk != 0)) {
 358                         mothurOut("Unable to rename " + outName); mothurOutEndLine();
 359                         perror(" : ");
 360                 }
 361         }
 362         catch(exception& e) {
 363                 errorOut(e, "OneColumnFile", "resetFile");
 364                 exit(1);
 365         }
 366 }
 367
 368 /***********************************************************************/
 369 /***********************************************************************/
 370
 371 SharedOneColumnFile::~SharedOneColumnFile(){
 372
 373         inFile.close();
 374         outFile.close();
 375         remove(outName.c_str());
 376 }
 377
 378 /***********************************************************************/
 379
 380 void SharedOneColumnFile::initFile(string label){
 381         try {
 382                 if(counter != 0){
 383                         openOutputFile(outName, outFile);
 384                         openInputFile(inName, inFile);
 385
 386                         string inputBuffer;
 387                         inputBuffer = getline(inFile);
 388
 389                         outFile <<  inputBuffer << '\t' << label  << endl;
 390
 391                 }
 392                 else{
 393                         openOutputFile(outName, outFile);
 394                         outFile << "sampled\t" << label << endl;
 395
 396                 }
 397
 398                 outFile.setf(ios::fixed, ios::floatfield);
 399                 outFile.setf(ios::showpoint);
 400         }
 401         catch(exception& e) {
 402                 errorOut(e, "SharedOneColumnFile", "initFile");
 403                 exit(1);
 404         }
 405 }
 406
 407 /***********************************************************************/
 408
 409 void SharedOneColumnFile::output(int nSeqs, vector<double> data){
 410         try {
 411                         string dataOutput;
 412                         float sam;
 413                         sam = data[0];
 414                         dataOutput = "";
 415                         for (int i = 0; i < data.size(); i++) {
 416                                 dataOutput = dataOutput + "\t" + toString(data[i]);
 417                         }
 418                         if(counter != 0){
 419                                 string inputBuffer;
 420                                 inputBuffer = getline(inFile);
 421
 422                                 outFile <<  inputBuffer << setprecision(2) << '\t' << dataOutput << endl;
 423                         }
 424                         else{
 425                                 outFile << nSeqs << setprecision(2) << '\t' << dataOutput << endl;
 426                         }
 427         }
 428         catch(exception& e) {
 429                 errorOut(e, "SharedOneColumnFile", "output");
 430                 exit(1);
 431         }
 432 }
 433
 434 /***********************************************************************/
 435
 436 void SharedOneColumnFile::resetFile(){
 437         try {
 438                 if(counter != 0){
 439                         outFile.close();
 440                         inFile.close();
 441                 }
 442                 else{
 443                         outFile.close();
 444                 }
 445                 counter = 1;
 446
 447                 remove(inName.c_str());
 448
 449                 renameOk = rename(outName.c_str(), inName.c_str());
 450
 451                 //checks to make sure user was able to rename and remove successfully
 452                 if ((renameOk != 0)) {
 453                         mothurOut("Unable to rename " + outName); mothurOutEndLine();
 454                         perror(" : ");
 455                 }
 456         }
 457         catch(exception& e) {
 458                 errorOut(e, "SharedOneColumnFile", "resetFile");
 459                 exit(1);
 460         }
 461 }
 462
 463 /***********************************************************************/