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
  29 #include "output.hh"
  30
  31 // This constant is used for allocating memory in Printer::printf
  32 #define FORMAT_BUFSIZE 100
  33
  34 //
  35 // Printer class
  36 //
  37
  38 Out::Printer::Printer(void printer(std::string))
  39 {
  40         this->printer = printer;
  41 }
  42
  43 Out::Printer&
  44 Out::Printer::operator<<(std::string msg)
  45 {
  46         this->printer(msg);
  47         return *this;
  48 }
  49
  50 Out::Printer&
  51 Out::Printer::operator<<(const char *msg)
  52 {
  53         this->printer(msg);
  54         return *this;
  55 }
  56
  57 Out::Printer&
  58 Out::Printer::operator<<(char msg)
  59 {
  60         this->printer(std::string(1, msg));
  61         return *this;
  62 }
  63
  64 Out::Printer&
  65 Out::Printer::operator<<(int msg)
  66 {
  67         std::ostringstream tmp;
  68         tmp << msg;
  69         this->printer(tmp.str());
  70         return *this;
  71 }
  72
  73 Out::Printer&
  74 Out::Printer::operator<<(short msg)
  75 {
  76         std::ostringstream tmp;
  77         tmp << msg;
  78         this->printer(tmp.str());
  79         return *this;
  80 }
  81
  82 Out::Printer&
  83 Out::Printer::operator<<(long msg)
  84 {
  85         std::ostringstream tmp;
  86         tmp << msg;
  87         this->printer(tmp.str());
  88         return *this;
  89 }
  90
  91 Out::Printer&
  92 Out::Printer::operator<<(long long msg)
  93 {
  94         std::ostringstream tmp;
  95         tmp << msg;
  96         this->printer(tmp.str());
  97         return *this;
  98 }
  99
 100 Out::Printer&
 101 Out::Printer::operator<<(unsigned int msg)
 102 {
 103         std::ostringstream tmp;
 104         tmp << msg;
 105         this->printer(tmp.str());
 106         return *this;
 107 }
 108
 109 Out::Printer&
 110 Out::Printer::operator<<(unsigned short msg)
 111 {
 112         std::ostringstream tmp;
 113         tmp << msg;
 114         this->printer(tmp.str());
 115         return *this;
 116 }
 117
 118 Out::Printer&
 119 Out::Printer::operator<<(unsigned long msg)
 120 {
 121         std::ostringstream tmp;
 122         tmp << msg;
 123         this->printer(tmp.str());
 124         return *this;
 125 }
 126
 127 Out::Printer&
 128 Out::Printer::operator<<(unsigned long long msg)
 129 {
 130         std::ostringstream tmp;
 131         tmp << msg;
 132         this->printer(tmp.str());
 133         return *this;
 134 }
 135
 136 Out::Printer&
 137 Out::Printer::operator<<(float msg)
 138 {
 139         std::ostringstream tmp;
 140         tmp << msg;
 141         this->printer(tmp.str());
 142         return *this;
 143 }
 144
 145 Out::Printer&
 146 Out::Printer::operator<<(double msg)
 147 {
 148         std::ostringstream tmp;
 149         tmp << msg;
 150         this->printer(tmp.str());
 151         return *this;
 152 }
 153
 154 int
 155 Out::Printer::vprintf(const char *format, va_list args)
 156 {
 157         int result;
 158         int length = std::strlen(format) + FORMAT_BUFSIZE;
 159         char *buffer = new char[length];
 160
 161         result = vsprintf(buffer, format, args);
 162
 163         if (result)
 164         {
 165                 std::ostringstream tmp;
 166                 tmp << buffer;
 167                 this->printer(tmp.str());
 168         }
 169         delete[] buffer;
 170         return result;
 171 }
 172
 173 int
 174 Out::Printer::printf(const char *format, ...)
 175 {
 176         int result;
 177         va_list args;
 178         va_start(args, format);
 179         result = this->vprintf(format, args);
 180         va_end(args);
 181         return result;
 182 }
 183
 184
 185
 186 //
 187 // Out class
 188 //
 189
 190 Out::Printer Out::fatal = Printer(Out::fatalPrinter);
 191 Out::Printer Out::error = Printer(Out::errorPrinter);
 192 Out::Printer Out::warning = Printer(Out::warningPrinter);
 193 Out::Printer Out::msg = Printer(Out::msgPrinter);
 194 Out::Printer Out::debug = Printer(Out::debugPrinter);
 195
 196 int Out::isWriting = 0;
 197 int Out::flags = 0;
 198
 199
 200 Out::Out()
 201 {
 202 }
 203
 204 int
 205 Out::getFlags()
 206 {
 207         return flags;
 208 }
 209
 210 void
 211 Out::setFlags(int newflags)
 212 {
 213         flags = newflags;
 214 }
 215
 216 void
 217 Out::fatalPrinter(std::string msg)
 218 {
 219         if (!(flags & FATAL))
 220                 return;
 221
 222         // If another command didn't finish its line, fix it for it
 223         if((isWriting | FATAL) != FATAL)
 224         {
 225                 std::cerr << std::endl;
 226                 isWriting = 0;
 227                 debug << "Printed an unfinished line" << endl;
 228         }
 229
 230         // Only write prefix one time per line
 231         if((isWriting & FATAL) == 0)
 232         {
 233                 std::cerr << "FATAL: ";
 234         }
 235
 236         // If msg is a finished line reset flags, else set flags
 237         if(msg.find('\n') == std::string::npos)
 238         {
 239                 isWriting = FATAL;
 240         }
 241         else
 242         {
 243                 isWriting = 0;
 244         }
 245
 246         std::cerr << msg;
 247 }
 248
 249 void
 250 Out::errorPrinter(std::string msg)
 251 {
 252         if (!(flags & ERROR))
 253                 return;
 254
 255         // If another command didn't finish its line, fix it for it
 256         if((isWriting | ERROR) != ERROR)
 257         {
 258                 std::cerr << std::endl;
 259                 debug << "Printed an unfinished line" << endl;
 260                 isWriting = 0;
 261         }
 262
 263         // Only write prefix one time per line
 264         if((isWriting & ERROR) == 0)
 265         {
 266                 std::cerr << "ERROR: ";
 267         }
 268
 269         // If msg is a finished line reset flags, else set flags
 270         if(msg.find('\n') == std::string::npos)
 271         {
 272                 isWriting = ERROR;
 273         }
 274         else
 275         {
 276                 isWriting = 0;
 277         }
 278
 279         std::cerr << msg;
 280 }
 281
 282 void
 283 Out::warningPrinter(std::string msg)
 284 {
 285         if (!(flags & WARNING))
 286                 return;
 287
 288         // If another command didn't finish its line, fix it for it
 289         if((isWriting | WARNING) != WARNING)
 290         {
 291                 std::cerr << std::endl;
 292                 isWriting = 0;
 293                 debug << "Printed an unfinished line" << endl;
 294         }
 295
 296         // Only write prefix one time per line
 297         if((isWriting & WARNING) == 0)
 298         {
 299                 std::cerr << "WARNING: ";
 300         }
 301
 302         // If msg is a finished line reset flags, else set flags
 303         if(msg.find('\n') == std::string::npos)
 304         {
 305                 isWriting = WARNING;
 306         }
 307         else
 308         {
 309                 isWriting = 0;
 310         }
 311
 312         std::cerr << msg;
 313 }
 314
 315 void
 316 Out::msgPrinter(std::string msg)
 317 {
 318         // If another command didn't finish its line, fix it for it
 319         if((isWriting | MSG) != MSG)
 320         {
 321                 std::cerr << std::endl;
 322                 isWriting = 0;
 323                 debug << "Printed an unfinished line" << endl;
 324         }
 325
 326         // If msg is a finished line reset flags, else set flags
 327         if(msg.find('\n') == std::string::npos)
 328         {
 329                 isWriting = MSG;
 330         }
 331         else
 332         {
 333                 isWriting = 0;
 334         }
 335
 336         std::cout << msg;
 337 }
 338
 339 void
 340 Out::debugPrinter(std::string msg)
 341 {
 342         if (!(flags & DEBUG))
 343                 return;
 344
 345         // If another command didn't finish its line, fix it for it
 346         if((isWriting | DEBUG) != DEBUG)
 347         {
 348                 std::cerr << std::endl;
 349                 isWriting = 0;
 350                 debug << "Printed an unfinished line" << endl;
 351         }
 352
 353         // Only write prefix one time per line
 354         if((isWriting & DEBUG) == 0)
 355         {
 356                 std::cerr << "DEBUG: ";
 357         }
 358
 359         // If msg is a finished line reset flags, else set flags
 360         if(msg.find('\n') == std::string::npos)
 361         {
 362                 isWriting = DEBUG;
 363         }
 364         else
 365         {
 366                 isWriting = 0;
 367         }
 368
 369         std::cerr << msg;
 370 }
 371