scexception.h

00001 //
00002 // scexception.h
00003 //
00004 // Copyright (C) 1996 Limit Point Systems, Inc.
00005 //
00006 // Author: Joseph Kenny <jpkenny@sandia.gov>
00007 // Maintainer: LPS
00008 //
00009 // This file is part of the SC Toolkit.
00010 //
00011 // The SC Toolkit is free software; you can redistribute it and/or modify
00012 // it under the terms of the GNU Library General Public License as published by
00013 // the Free Software Foundation; either version 2, or (at your option)
00014 // any later version.
00015 //
00016 // The SC Toolkit is distributed in the hope that it will be useful,
00017 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00018 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019 // GNU Library General Public License for more details.
00020 //
00021 // You should have received a copy of the GNU Library General Public License
00022 // along with the SC Toolkit; see the file COPYING.LIB.  If not, write to
00023 // the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
00024 //
00025 // The U.S. Government is granted a limited license as per AL 91-7.
00026 //
00027 
00028 #ifdef __GNUC__
00029 #pragma interface
00030 #endif
00031 
00032 #ifndef _util_misc_scexception_h
00033 #define _util_misc_scexception_h
00034 
00035 #ifndef _util_class_class_h
00036 #include <util/class/class.h>
00037 #endif
00038 
00039 #include <stddef.h>
00040 #include <exception>
00041 #include <sstream>
00042 #include <vector>
00043 
00044 namespace sc {
00045 
00049 class SCException: public std::exception {
00050     const char *description_;
00051     const char *file_;
00052     int line_;
00053     const ClassDesc* class_desc_;
00054     const char *exception_type_;
00055     std::ostringstream *elaboration_;
00056 
00057   public:
00058     SCException(const char *description = 0,
00059                 const char *file = 0,
00060                 int line = 0,
00061                 const ClassDesc *class_desc = 0,
00062                 const char *exception_type = "SCException") throw();
00063     SCException(const SCException&) throw();
00064     ~SCException() throw();
00065 
00068     const char* what() const throw();
00069 
00070     const char *description() const throw() { return description_; }
00071     const char *file() const throw() { return file_; }
00072     int line() const throw() { return line_; }
00073     const ClassDesc *class_desc() const throw() { return class_desc_; }
00074     const char *exception_type() const throw() { return exception_type_; }
00075 
00079     std::ostream &elaborate();
00080 };
00081 
00082 // ///////////////////////////////////////////////////////////////////////
00083 // Programming Error Exceptions
00084 
00087 class ProgrammingError: public SCException {
00088 
00089   public:
00090     ProgrammingError(const char *description = 0,
00091                      const char *file = 0,
00092                      int line = 0,
00093                      const ClassDesc *class_desc = 0,
00094                      const char *exception_type = "ProgrammingError") throw();
00095     ProgrammingError(const ProgrammingError&) throw();
00096     ~ProgrammingError() throw();
00097 };
00098 
00102 class FeatureNotImplemented: public ProgrammingError {
00103 
00104   public:
00105     FeatureNotImplemented(const char *description = 0,
00106                           const char *file = 0,
00107                           int line = 0,
00108                           const ClassDesc *class_desc = 0,
00109                           const char *exception_type = "FeatureNotImplemented")
00110         throw();
00111     FeatureNotImplemented(const FeatureNotImplemented&) throw();
00112     ~FeatureNotImplemented() throw();
00113 };
00114 
00115 // ///////////////////////////////////////////////////////////////////////
00116 // Input Error Exceptions
00117 
00122 class InputError: public SCException {
00123     const char *keyword_;
00124     char *value_;
00125 
00126   public:
00127     InputError(const char *description = 0,
00128                const char *file = 0,
00129                int line = 0,
00130                const char *keyword = 0,
00131                const char *value = 0,
00132                const ClassDesc *class_desc = 0,
00133                const char *exception_type = "InputError") throw();
00134     InputError(const InputError&) throw();
00135     ~InputError() throw();
00136     const char *keyword() const throw() { return keyword_; }
00137     const char *value() const throw() { return value_; }
00138 };
00139 
00140 // ///////////////////////////////////////////////////////////////////////
00141 // System Exceptions
00142 
00145 class SystemException: public SCException {
00146 
00147   public:
00148     SystemException(const char *description = 0,
00149                     const char *file = 0,
00150                     int line = 0,
00151                     const ClassDesc *class_desc = 0,
00152                     const char *exception_type = "SystemException") throw();
00153     SystemException(const SystemException&) throw();
00154     ~SystemException() throw();
00155 };
00156 
00159 class MemAllocFailed: public SystemException {
00160     size_t nbyte_;
00161 
00162   public:
00163     MemAllocFailed(const char *description = 0,
00164                    const char *file = 0,
00165                    int line = 0,
00166                    size_t nbyte = 0,
00167                    const ClassDesc *class_desc = 0,
00168                    const char *exception_type = "MemAllocFailed") throw();
00169     MemAllocFailed(const MemAllocFailed&) throw();
00170     ~MemAllocFailed() throw();
00171 
00173     size_t nbyte() const throw() { return nbyte_; }
00174 };
00175 
00178 class FileOperationFailed: public SystemException {
00179   public:
00180     enum FileOperation { Unknown, OpenR, OpenW, OpenRW,
00181                          Close, Read, Write, Corrupt, Other };
00182 
00183   private:
00184     const char *filename_;
00185     FileOperation operation_;
00186 
00187   public:
00188     FileOperationFailed(const char *description = 0,
00189                    const char *source_file = 0,
00190                    int line = 0,
00191                    const char *filename = 0,
00192                    FileOperation operation = Unknown,
00193                    const ClassDesc *class_desc = 0,
00194                    const char *exception_type = "FileOperationFailed") throw();
00195     FileOperationFailed(const FileOperationFailed&) throw();
00196     ~FileOperationFailed() throw();
00197 
00200     const char * filename() const throw() { return filename_; }
00201     FileOperation operation() const throw() { return operation_; }
00202 };
00203 
00206 class SyscallFailed: public SystemException {
00207     const char *syscall_;
00208     int err_;
00209 
00210   public:
00211     SyscallFailed(const char *description = 0,
00212                   const char *source_file = 0,
00213                   int line = 0,
00214                   const char *syscall = 0,
00215                   int err = 0, 
00216                   const ClassDesc *class_desc = 0,
00217                   const char *exception_type = "SyscallFailed") throw();
00218     SyscallFailed(const SyscallFailed&) throw();
00219     ~SyscallFailed() throw();
00220 
00223     const char * syscall() const throw() { return syscall_; }
00224     int err() const throw() { return err_; }
00225 };
00226 
00227 // ///////////////////////////////////////////////////////////////////////
00228 // Algorithm Exceptions
00229 
00233 class AlgorithmException: public SCException {
00234 
00235   public:
00236     AlgorithmException(const char *description = 0,
00237                        const char *file = 0,
00238                        int line = 0,
00239                        const ClassDesc *class_desc = 0,
00240                        const char *exception_type = "AlgorithmException")
00241         throw();
00242     AlgorithmException(const AlgorithmException&) throw();
00243     ~AlgorithmException() throw();
00244 };
00245 
00249 class MaxIterExceeded: public AlgorithmException {
00250     int max_iter_;
00251 
00252   public:
00253     MaxIterExceeded(const char *description = 0,
00254                     const char *file = 0,
00255                     int line = 0,
00256                     int maxiter = 0,
00257                     const ClassDesc *class_desc = 0,
00258                     const char *exception_type = "MaxIterExceeded") throw();
00259     MaxIterExceeded(const MaxIterExceeded&) throw();
00260     ~MaxIterExceeded() throw();
00261 
00262     int max_iter() const throw() { return max_iter_; }
00263 };
00264 
00267 class ToleranceExceeded: public AlgorithmException {
00268     double tolerance_;
00269     double value_;
00270 
00271 public:
00272     ToleranceExceeded(const char *description = 0,
00273                       const char *file = 0,
00274                       int line = 0,
00275                       double tol=0,
00276                       double val=0,
00277                       const ClassDesc *class_desc = 0,
00278                       const char *exception_type = "ToleranceExceeded") throw();
00279     ToleranceExceeded(const ToleranceExceeded&) throw();
00280     ~ToleranceExceeded() throw();
00281     double tolerance() throw() { return tolerance_; }
00282     double value() throw() { return value_; }
00283 };
00284 
00285 // ///////////////////////////////////////////////////////////////////////
00286 // Limit Exceeded Exceptions
00287 
00292 template <class T>
00293 class LimitExceeded: public SCException {
00294     T limit_;
00295     T value_;
00296 
00297 public:
00298     LimitExceeded(const char *description,
00299                   const char *file,
00300                   int line,
00301                   T lim,
00302                   T val,
00303                   const ClassDesc *class_desc = 0,
00304                   const char *exception_type = "LimitExceeded") throw():
00305       SCException(description, file, line, class_desc, exception_type),
00306       limit_(lim), value_(val)
00307         {
00308           try {
00309               elaborate() << "value:       " << value_
00310                           << std::endl
00311                           << "limit:       " << limit_
00312                           << std::endl;
00313             }
00314           catch(...) {
00315             }
00316         }
00317     LimitExceeded(const LimitExceeded&ref) throw():
00318       SCException(ref),
00319       limit_(ref.limit_), value_(ref.value_)
00320         {
00321         }
00322     ~LimitExceeded() throw() {}
00323     T tolerance() throw() { return limit_; }
00324     T value() throw() { return value_; }
00325 };
00326 
00327 }
00328 
00329 #endif
00330 

Generated at Mon Dec 3 23:23:41 2007 for MPQC 2.3.1 using the documentation package Doxygen 1.5.2.