src/error.hh

   1 /*
   2  * This file includes global error routines used throughout OpenStranded
   3  *
   4  * Copyright (C) 2008 Hermann Walth
   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 #ifndef STRANDED_ERROR_HH
  23 #define STRANDED_ERROR_HH
  24
  25 #include <iostream>
  26 #include <string>
  27 #include <exception>
  28
  29 /**
  30  * The StrandedException base class.
  31  * OpenStranded uses a classical Warning - Error - Fatal exception
  32  * level scheme.
  33  * You should use the following classes instead of their StrandedException
  34  * base class.
  35  * NOTE: Implementation of warnings through exceptions is somewhat difficult,
  36  * for you will most probably want to continue your function without disruption
  37  * after throwing a Warning, exceptions will, however, always break out of the
  38  * function.
  39  * Therefore you should not throw this exception if there is another
  40  * approach to this problem.
  41  * @see StrandedWarning
  42  * @see StrandedError
  43  * @see StrandedFatal
  44  */
  45 class StrandedException: public std::exception
  46 {
  47         private:
  48                 /**
  49                  * The error message.
  50                  */
  51                 std::string message;
  52
  53         public:
  54                 /**
  55                  * The constructor.
  56                  * @param message The error message
  57                  */
  58                 StrandedException (const char* message);
  59
  60                 /**
  61                  * The constructor.
  62                  * @param message The error message
  63                  */
  64                 StrandedException (const std::string& message);
  65
  66                 /**
  67                  * The destructor.
  68                  */
  69                 ~StrandedException () throw ();
  70
  71                 /**
  72                  * This is a virtual method of the std::exception class
  73                  * @return The error message
  74                  */
  75                 const char*
  76                 what () throw ();
  77
  78                 /**
  79                  * Print the error message.
  80                  */
  81                 virtual void
  82                 print ();
  83 };
  84
  85
  86
  87 /**
  88  * This class defines an Exception with the "Warning" level.
  89  * Consider the comments on the StrandedException base class.
  90  * @see StrandedException
  91  */
  92 class StrandedWarning: public StrandedException
  93 {
  94         public:
  95                 /**
  96                  * The constructor.
  97                  * @param message The error message
  98                  */
  99                 StrandedWarning (const char* message);
 100
 101                 /**
 102                  * The constructor.
 103                  * @param message The error message
 104                  */
 105                 StrandedWarning (const std::string& message);
 106
 107                 /**
 108                  * Print the error message.
 109                  * This method will print the error message preceded by an
 110                  * indicator of the error level.
 111                  */
 112                 void
 113                 print ();
 114 };
 115
 116
 117 /**
 118  * This class defines an Exception with the "Error" level.
 119  * Consider the comments on the StrandedException base class.
 120  * @see StrandedException
 121  */
 122 class StrandedError: public StrandedException
 123 {
 124         public:
 125                 /**
 126                  * The constructor.
 127                  * @param message The error message
 128                  */
 129                 StrandedError (const char* message);
 130
 131                 /**
 132                  * The constructor.
 133                  * @param message The error message
 134                  */
 135                 StrandedError (const std::string& message);
 136
 137                 /**
 138                  * Print the error message.
 139                  * This method will print the error message preceded by an
 140                  * indicator of the error level.
 141                  */
 142                 void
 143                 print ();
 144 };
 145
 146
 147 /**
 148  * This class defines an Exception with the "Fatal" level.
 149  * Consider the comments on the StrandedException base class.
 150  * @see StrandedException
 151  */
 152 class StrandedFatal: public StrandedException
 153 {
 154         public:
 155                 /**
 156                  * The constructor.
 157                  * @param message The error message
 158                  */
 159                 StrandedFatal (const char* message);
 160
 161                 /**
 162                  * The constructor.
 163                  * @param message The error message
 164                  */
 165                 StrandedFatal (const std::string& message);
 166
 167                 /**
 168                  * Print the error message.
 169                  * This method will print the error message preceded by an
 170                  * indicator of the error level.
 171                  */
 172                 void
 173                 print ();
 174 };
 175
 176 #endif /* STRANDED_ERROR_HH */