src/output.cc

   1 /*
   2  * See output.hh for more information about this file
   3  *
   4  * Copyright (C) 2009 David Kolossa
   5  *
   6  * This file is part of OpenStranded.
   7  *
   8  * OpenStranded is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation, either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * OpenStranded is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with OpenStranded. If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <iostream>
  23 #include <sstream>
  24 #include <string>
  25 #include <cstdarg>
  26 #include <cstdio>
  27 #include <cstring>
  28 #include <cstdlib>
  29 #include <cassert>
  30 #ifndef WIN32
  31         // Directory handling
  32         #include <dirent.h>
  33         #include <sys/stat.h>
  34         #include <sys/types.h>
  35 #endif
  36 #include <ctime>
  37
  38 #include "filesystem.hh"
  39 #include "output.hh"
  40
  41 // This constant is used for allocating memory in Printer::printf
  42 #define FORMAT_BUFSIZE 100
  43
  44 //
  45 // Printer class
  46 //
  47
  48 Out::Printer::Printer(void printer(std::string))
  49 {
  50         this->printer = printer;
  51 }
  52
  53 Out::Printer&
  54 Out::Printer::operator<<(std::string msg)
  55 {
  56         this->printer(msg);
  57         return *this;
  58 }
  59
  60 Out::Printer&
  61 Out::Printer::operator<<(const char *msg)
  62 {
  63         this->printer(msg);
  64         return *this;
  65 }
  66
  67 Out::Printer&
  68 Out::Printer::operator<<(char msg)
  69 {
  70         this->printer(std::string(1, msg));
  71         return *this;
  72 }
  73
  74 Out::Printer&
  75 Out::Printer::operator<<(int msg)
  76 {
  77         std::ostringstream tmp;
  78         tmp << msg;
  79         this->printer(tmp.str());
  80         return *this;
  81 }
  82
  83 Out::Printer&
  84 Out::Printer::operator<<(short msg)
  85 {
  86         std::ostringstream tmp;
  87         tmp << msg;
  88         this->printer(tmp.str());
  89         return *this;
  90 }
  91
  92 Out::Printer&
  93 Out::Printer::operator<<(long msg)
  94 {
  95         std::ostringstream tmp;
  96         tmp << msg;
  97         this->printer(tmp.str());
  98         return *this;
  99 }
 100
 101 Out::Printer&
 102 Out::Printer::operator<<(long long msg)
 103 {
 104         std::ostringstream tmp;
 105         tmp << msg;
 106         this->printer(tmp.str());
 107         return *this;
 108 }
 109
 110 Out::Printer&
 111 Out::Printer::operator<<(unsigned int msg)
 112 {
 113         std::ostringstream tmp;
 114         tmp << msg;
 115         this->printer(tmp.str());
 116         return *this;
 117 }
 118
 119 Out::Printer&
 120 Out::Printer::operator<<(unsigned short msg)
 121 {
 122         std::ostringstream tmp;
 123         tmp << msg;
 124         this->printer(tmp.str());
 125         return *this;
 126 }
 127
 128 Out::Printer&
 129 Out::Printer::operator<<(unsigned long msg)
 130 {
 131         std::ostringstream tmp;
 132         tmp << msg;
 133         this->printer(tmp.str());
 134         return *this;
 135 }
 136
 137 Out::Printer&
 138 Out::Printer::operator<<(unsigned long long msg)
 139 {
 140         std::ostringstream tmp;
 141         tmp << msg;
 142         this->printer(tmp.str());
 143         return *this;
 144 }
 145
 146 Out::Printer&
 147 Out::Printer::operator<<(float msg)
 148 {
 149         std::ostringstream tmp;
 150         tmp << msg;
 151         this->printer(tmp.str());
 152         return *this;
 153 }
 154
 155 Out::Printer&
 156 Out::Printer::operator<<(double msg)
 157 {
 158         std::ostringstream tmp;
 159         tmp << msg;
 160         this->printer(tmp.str());
 161         return *this;
 162 }
 163
 164 int
 165 Out::Printer::vprintf(const char *format, va_list args)
 166 {
 167         int result;
 168         int length = std::strlen(format) + FORMAT_BUFSIZE;
 169         char *buffer = new char[length];
 170
 171         result = vsprintf(buffer, format, args);
 172
 173         if (result)
 174         {
 175                 std::ostringstream tmp;
 176                 tmp << buffer;
 177                 this->printer(tmp.str());
 178         }
 179         delete[] buffer;
 180         return result;
 181 }
 182
 183 int
 184 Out::Printer::printf(const char *format, ...)
 185 {
 186         int result;
 187         va_list args;
 188         va_start(args, format);
 189         result = this->vprintf(format, args);
 190         va_end(args);
 191         return result;
 192 }
 193
 194
 195
 196 //
 197 // Out class
 198 //
 199
 200 Out::Printer Out::fatal = Printer(Out::fatalPrinter);
 201 Out::Printer Out::error = Printer(Out::errorPrinter);
 202 Out::Printer Out::warning = Printer(Out::warningPrinter);
 203 Out::Printer Out::msg = Printer(Out::msgPrinter);
 204 Out::Printer Out::debug = Printer(Out::debugPrinter);
 205
 206 int Out::isWriting = Out::NONE;
 207 int Out::consoleFlags = Out::NONE;
 208 int Out::loggingFlags = Out::NONE;
 209
 210 FILE *Out::logFile = 0;
 211
 212
 213 Out::Out()
 214 {
 215 }
 216
 217 void
 218 Out::setLogFile(std::string fileName)
 219 {
 220         if (Out::logFile != 0)
 221         {
 222                 fclose(Out::logFile);
 223                 Out::logFile = 0;
 224         }
 225         std::string path = "";
 226         #ifndef WIN32
 227                 path += std::getenv("HOME");
 228                 path += "/.openstranded/";
 229                 if(opendir(path.c_str()) == NULL)
 230                 {
 231                         FileSystem::initUserDirectory();
 232                 }
 233
 234         #else
 235                 // TODO: Add Windows directory code.
 236                 path = "./";
 237         #endif
 238
 239
 240
 241         path += fileName;
 242         Out::logFile = std::fopen(path.c_str(), "a");
 243         if(Out::logFile == 0)
 244         {
 245                 std::cerr << "FATAL: Log file could not be opened" << std::endl;
 246                 return;
 247         }
 248
 249         /*
 250          * Timestamp code taken from PeakEngine and modified
 251          * <http://peakengine.sourceforge.net/>
 252          */
 253         std::time_t rawtime;
 254         std::time(&rawtime);
 255         struct std::tm *timeinfo = std::localtime(&rawtime);
 256         char timestr[20];
 257         std::strftime(timestr, 20, "%x %X", timeinfo);
 258         std::fprintf(Out::logFile, "================\nOpened logfile on %s\n================", timestr);
 259         std::fflush(Out::logFile);
 260 }
 261
 262 int
 263 Out::getConsoleFlags()
 264 {
 265         return consoleFlags;
 266 }
 267
 268 void
 269 Out::setConsoleFlags(int newflags)
 270 {
 271         consoleFlags = newflags;
 272 }
 273
 274 int
 275 Out::getLoggingFlags()
 276 {
 277         return loggingFlags;
 278 }
 279
 280 void
 281 Out::setLoggingFlags(int newflags)
 282 {
 283         loggingFlags = newflags;
 284 }
 285
 286 void
 287 Out::fatalPrinter(std::string msg)
 288 {
 289         if (!(consoleFlags & FATAL) && !(loggingFlags & FATAL))
 290                 return;
 291
 292         // If another command didn't finish its line, fix it for it
 293         if((isWriting | FATAL) != FATAL)
 294         {
 295                 std::cerr << std::endl;
 296                 isWriting = 0;
 297                 debug << "Printed an unfinished line" << endl;
 298         }
 299
 300         // Only write prefix one time per line
 301         if((isWriting & FATAL) == 0)
 302         {
 303                 msg = "FATAL: " + msg;
 304         }
 305
 306         // If msg is a finished line reset flags, else set flags
 307         if(msg.find('\n') == std::string::npos)
 308         {
 309                 isWriting = FATAL;
 310         }
 311         else
 312         {
 313                 isWriting = 0;
 314         }
 315
 316         if(consoleFlags & FATAL)
 317         {
 318                 std::cerr << msg;
 319         }
 320
 321         if(loggingFlags & FATAL)
 322         {
 323                 assert(Out::logFile != 0);
 324                 const char *logMsg = msg.c_str();
 325                 fwrite(logMsg, std::strlen(logMsg), sizeof(char),  Out::logFile);
 326                 fflush(Out::logFile);
 327         }
 328 }
 329
 330 void
 331 Out::errorPrinter(std::string msg)
 332 {
 333         if (!(consoleFlags & ERROR) && !(loggingFlags & ERROR))
 334                 return;
 335
 336         // If another command didn't finish its line, fix it for it
 337         if((isWriting | ERROR) != ERROR)
 338         {
 339                 std::cerr << std::endl;
 340                 debug << "Printed an unfinished line" << endl;
 341                 isWriting = 0;
 342         }
 343
 344         // Only write prefix one time per line
 345         if((isWriting & ERROR) == 0)
 346         {
 347                 msg = "ERROR: " + msg;
 348         }
 349
 350         // If msg is a finished line reset consoleFlags, else set flags
 351         if(msg.find('\n') == std::string::npos)
 352         {
 353                 isWriting = ERROR;
 354         }
 355         else
 356         {
 357                 isWriting = 0;
 358         }
 359
 360         if(consoleFlags & ERROR)
 361         {
 362                 std::cerr << msg;
 363         }
 364
 365         if(loggingFlags & ERROR)
 366         {
 367                 assert(Out::logFile != 0);
 368                 const char *logMsg = msg.c_str();
 369                 fwrite(logMsg, std::strlen(logMsg), sizeof(char),  Out::logFile);
 370                 fflush(Out::logFile);
 371         }
 372 }
 373
 374 void
 375 Out::warningPrinter(std::string msg)
 376 {
 377         if (!(consoleFlags & WARNING) && !(loggingFlags & WARNING))
 378                 return;
 379
 380         // If another command didn't finish its line, fix it for it
 381         if((isWriting | WARNING) != WARNING)
 382         {
 383                 std::cerr << std::endl;
 384                 isWriting = 0;
 385                 debug << "Printed an unfinished line" << endl;
 386         }
 387
 388         // Only write prefix one time per line
 389         if((isWriting & WARNING) == 0)
 390         {
 391                 msg = "WARNING: " + msg;
 392         }
 393
 394         // If msg is a finished line reset flags, else set flags
 395         if(msg.find('\n') == std::string::npos)
 396         {
 397                 isWriting = WARNING;
 398         }
 399         else
 400         {
 401                 isWriting = 0;
 402         }
 403
 404         if(consoleFlags & WARNING)
 405         {
 406                 std::cerr << msg;
 407         }
 408
 409         if(loggingFlags & WARNING)
 410         {
 411                 assert(Out::logFile != 0);
 412                 const char *logMsg = msg.c_str();
 413                 fwrite(logMsg, std::strlen(logMsg), sizeof(char),  Out::logFile);
 414                 fflush(Out::logFile);
 415         }
 416 }
 417
 418 void
 419 Out::msgPrinter(std::string msg)
 420 {
 421         // If another command didn't finish its line, fix it for it
 422         if((isWriting | MSG) != MSG)
 423         {
 424                 std::cerr << std::endl;
 425                 isWriting = 0;
 426                 debug << "Printed an unfinished line" << endl;
 427         }
 428
 429         // If msg is a finished line reset flags, else set flags
 430         if(msg.find('\n') == std::string::npos)
 431         {
 432                 isWriting = MSG;
 433         }
 434         else
 435         {
 436                 isWriting = 0;
 437         }
 438
 439         std::cout << msg;
 440 }
 441
 442 void
 443 Out::debugPrinter(std::string msg)
 444 {
 445         if (!(consoleFlags & DEBUG) && !(loggingFlags & DEBUG))
 446                 return;
 447
 448         // If another command didn't finish its line, fix it for it
 449         if((isWriting | DEBUG) != DEBUG)
 450         {
 451                 std::cerr << std::endl;
 452                 isWriting = 0;
 453                 debug << "Printed an unfinished line" << endl;
 454         }
 455
 456         // Only write prefix one time per line
 457         if((isWriting & DEBUG) == 0)
 458         {
 459                 msg = "DEBUG: " + msg;
 460         }
 461
 462         // If msg is a finished line reset flags, else set flags
 463         if(msg.find('\n') == std::string::npos)
 464         {
 465                 isWriting = DEBUG;
 466         }
 467         else
 468         {
 469                 isWriting = 0;
 470         }
 471
 472         if(consoleFlags & DEBUG)
 473         {
 474                 std::cerr << msg;
 475         }
 476
 477         if(loggingFlags & DEBUG)
 478         {
 479                 assert(Out::logFile != 0);
 480                 const char *logMsg = msg.c_str();
 481                 fwrite(logMsg, std::strlen(logMsg), sizeof(char),  Out::logFile);
 482                 fflush(Out::logFile);
 483         }
 484 }
 485