src/output.hh

   1 /*
   2  * This file includes definitions for OpenStranded output mapping
   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 <string>
  24 #include <cstdarg>
  25
  26 /**
  27  * This is the class for OpenStranded output to either cout or cerr.
  28  */
  29 class Out
  30 {
  31         private:
  32                 class Printer
  33                 {
  34                         private:
  35                                 void (*printer)(std::string);
  36
  37                         public:
  38                                 Printer(void (*printer)(std::string));
  39
  40
  41
  42                                 //
  43                                 // Texts
  44                                 //
  45
  46                                 Printer&
  47                                 operator<<(std::string msg);
  48
  49                                 Printer&
  50                                 operator<<(const char *msg);
  51
  52                                 Printer&
  53                                 operator<<(char msg);
  54
  55
  56
  57                                 //
  58                                 // Signed integers
  59                                 //
  60
  61                                 Printer&
  62                                 operator<<(int msg);
  63
  64                                 Printer&
  65                                 operator<<(short msg);
  66
  67                                 Printer&
  68                                 operator<<(long msg);
  69
  70                                 Printer&
  71                                 operator<<(long long msg);
  72
  73
  74
  75                                 //
  76                                 // Unsigned integers
  77                                 //
  78
  79                                 Printer&
  80                                 operator<<(unsigned int msg);
  81
  82                                 Printer&
  83                                 operator<<(unsigned short msg);
  84
  85                                 Printer&
  86                                 operator<<(unsigned long msg);
  87
  88                                 Printer&
  89                                 operator<<(unsigned long long msg);
  90
  91
  92
  93                                 //
  94                                 // Decimals
  95                                 //
  96
  97                                 Printer&
  98                                 operator<<(float msg);
  99
 100                                 Printer&
 101                                 operator<<(double msg);
 102
 103
 104
 105                                 //
 106                                 // Format strings
 107                                 //
 108
 109                                 int
 110                                 vprintf(const char *format, va_list args);
 111
 112                                 int
 113                                 printf(const char *format, ...);
 114                 };
 115
 116         public:
 117                 /**
 118                  * The mode flags.
 119                  * These flags determine which messages are displayed and which
 120                  * not.
 121                  */
 122                 static int flags;
 123
 124                 /**
 125                  * These flags indicate whether a printer has not finished its
 126                  * line.
 127                  */
 128                 static int isWriting;
 129
 130                 /**
 131                  * Print fatal error message to stderr.
 132                  * @param The message
 133                  */
 134                 static void
 135                 fatalPrinter(std::string msg);
 136
 137                 /**
 138                  * Print common error message to stderr.
 139                  * @param The message
 140                  */
 141                 static void
 142                 errorPrinter(std::string msg);
 143
 144                 /**
 145                  * Print warning message to stderr.
 146                  * @param The message
 147                  */
 148                 static void
 149                 warningPrinter(std::string msg);
 150
 151                 /**
 152                  * Print a common message to stdout.
 153                  * Note that these messages can't be shut off.
 154                  * @param The message
 155                  */
 156                 static void
 157                 msgPrinter(std::string msg);
 158
 159                 /**
 160                  * Print a debug message.
 161                  * @param The message
 162                  */
 163                 static void
 164                 debugPrinter(std::string msg);
 165
 166
 167                 /**
 168                  * The fatal stream.
 169                  */
 170                 static Printer fatal;
 171
 172                 /**
 173                  * The error stream.
 174                  */
 175                 static Printer error;
 176
 177                 /**
 178                  * The warning stream.
 179                  */
 180                 static Printer warning;
 181
 182                 /**
 183                  * The msg stream.
 184                  */
 185                 static Printer msg;
 186
 187                 /**
 188                  * The debug stream.
 189                  */
 190                 static Printer debug;
 191
 192                 static const int FATAL = 1;
 193                 static const int ERROR = 2;
 194                 static const int WARNING = 4;
 195                 static const int DEBUG = 8;
 196                 static const int MSG = 16;      // only used internally
 197
 198                 static const char endl = '\n';
 199
 200                 Out();
 201
 202                 /**
 203                  * Get mode flags.
 204                  * @return The current mode flags.
 205                  */
 206                 static int
 207                 getFlags();
 208
 209                 /**
 210                  * Set mode flags.
 211                  * @param newflags The new mode flags.
 212                  */
 213                 static void
 214                 setFlags(int newflags);
 215 };
 216