scexception.h

//
// scexception.h
//
// Copyright (C) 1996 Limit Point Systems, Inc.
//
// Author: Joseph Kenny <jpkenny@sandia.gov>
// Maintainer: LPS
//
// This file is part of the SC Toolkit.
//
// The SC Toolkit is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// The SC Toolkit is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public License
// along with the SC Toolkit; see the file COPYING.LIB.  If not, write to
// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
//
// The U.S. Government is granted a limited license as per AL 91-7.
//
 
#ifndef _util_misc_scexception_h
#define _util_misc_scexception_h
 
#include <stdexcept>
#include <util/misc/exception.h>
#include <sstream>
#include <vector>
#include <util/class/class.h>
#include <util/misc/bug.h>
 
namespace sc {
 
class SCException: public Exception {
    const ClassDesc* class_desc_;
    const char *exception_type_;
    mutable char *elaboration_c_str_;
    std::ostringstream *elaboration_;
    Debugger::Backtrace backtrace_;
 
  public:
    SCException(const char *description = 0,
                const char *file = 0,
                int line = 0,
                const ClassDesc *class_desc = 0,
                const char *exception_type = "SCException") MPQC__NOEXCEPT;
    SCException(const SCException&) MPQC__NOEXCEPT;
    ~SCException() MPQC__NOEXCEPT;
 
    const char* what() const MPQC__NOEXCEPT;
 
    const ClassDesc *class_desc() const MPQC__NOEXCEPT { return class_desc_; }
    const char *exception_type() const MPQC__NOEXCEPT { return exception_type_; }
 
    std::ostream &elaborate();
};
 
// ///////////////////////////////////////////////////////////////////////
// Programming Error Exceptions
 
class ProgrammingError: public SCException {
 
  public:
    ProgrammingError(const char *description = 0,
                     const char *file = 0,
                     int line = 0,
                     const ClassDesc *class_desc = 0,
                     const char *exception_type = "ProgrammingError") MPQC__NOEXCEPT;
    ProgrammingError(const ProgrammingError&) MPQC__NOEXCEPT;
    ~ProgrammingError() MPQC__NOEXCEPT;
};
 
class FeatureNotImplemented: public ProgrammingError {
 
  public:
    FeatureNotImplemented(const char *description = 0,
                          const char *file = 0,
                          int line = 0,
                          const ClassDesc *class_desc = 0,
                          const char *exception_type = "FeatureNotImplemented")
        MPQC__NOEXCEPT;
    FeatureNotImplemented(const FeatureNotImplemented&) MPQC__NOEXCEPT;
    ~FeatureNotImplemented() MPQC__NOEXCEPT;
};
 
// ///////////////////////////////////////////////////////////////////////
// Input Error Exceptions
 
class InputError: public SCException {
    const char *keyword_;
    char *value_;
 
  public:
    InputError(const char *description = 0,
               const char *file = 0,
               int line = 0,
               const char *keyword = 0,
               const char *value = 0,
               const ClassDesc *class_desc = 0,
               const char *exception_type = "InputError") MPQC__NOEXCEPT;
    InputError(const InputError&) MPQC__NOEXCEPT;
    ~InputError() MPQC__NOEXCEPT;
    const char *keyword() const MPQC__NOEXCEPT { return keyword_; }
    const char *value() const MPQC__NOEXCEPT { return value_; }
};
 
// ///////////////////////////////////////////////////////////////////////
// System Exceptions
 
class SystemException: public SCException {
 
  public:
    SystemException(const char *description = 0,
                    const char *file = 0,
                    int line = 0,
                    const ClassDesc *class_desc = 0,
                    const char *exception_type = "SystemException") MPQC__NOEXCEPT;
    SystemException(const SystemException&) MPQC__NOEXCEPT;
    ~SystemException() MPQC__NOEXCEPT;
};
 
class MemAllocFailed: public SystemException {
    size_t nbyte_;
 
  public:
    MemAllocFailed(const char *description = 0,
                   const char *file = 0,
                   int line = 0,
                   size_t nbyte = 0,
                   const ClassDesc *class_desc = 0,
                   const char *exception_type = "MemAllocFailed") MPQC__NOEXCEPT;
    MemAllocFailed(const MemAllocFailed&) MPQC__NOEXCEPT;
    ~MemAllocFailed() MPQC__NOEXCEPT;
 
    size_t nbyte() const MPQC__NOEXCEPT { return nbyte_; }
};
 
class FileOperationFailed: public SystemException {
  public:
    enum FileOperation { Unknown, OpenR, OpenW, OpenRW,
                         Close, Read, Write, Corrupt, Other };
 
  private:
    const char *filename_;
    FileOperation operation_;
 
  public:
    FileOperationFailed(const char *description = 0,
                   const char *source_file = 0,
                   int line = 0,
                   const char *filename = 0,
                   FileOperation operation = Unknown,
                   const ClassDesc *class_desc = 0,
                   const char *exception_type = "FileOperationFailed") MPQC__NOEXCEPT;
    FileOperationFailed(const FileOperationFailed&) MPQC__NOEXCEPT;
    ~FileOperationFailed() MPQC__NOEXCEPT;
 
    const char * filename() const MPQC__NOEXCEPT { return filename_; }
    FileOperation operation() const MPQC__NOEXCEPT { return operation_; }
};
 
class SyscallFailed: public SystemException {
    const char *syscall_;
    int err_;
 
  public:
    SyscallFailed(const char *description = 0,
                  const char *source_file = 0,
                  int line = 0,
                  const char *syscall = 0,
                  int err = 0, 
                  const ClassDesc *class_desc = 0,
                  const char *exception_type = "SyscallFailed") MPQC__NOEXCEPT;
    SyscallFailed(const SyscallFailed&) MPQC__NOEXCEPT;
    ~SyscallFailed() MPQC__NOEXCEPT;
 
    const char * syscall() const MPQC__NOEXCEPT { return syscall_; }
    int err() const MPQC__NOEXCEPT { return err_; }
};
 
// ///////////////////////////////////////////////////////////////////////
// Algorithm Exceptions
 
class AlgorithmException: public SCException {
 
  public:
    AlgorithmException(const char *description = 0,
                       const char *file = 0,
                       int line = 0,
                       const ClassDesc *class_desc = 0,
                       const char *exception_type = "AlgorithmException")
        MPQC__NOEXCEPT;
    AlgorithmException(const AlgorithmException&) MPQC__NOEXCEPT;
    ~AlgorithmException() MPQC__NOEXCEPT;
};
 
class MaxIterExceeded: public AlgorithmException {
    int max_iter_;
 
  public:
    MaxIterExceeded(const char *description = 0,
                    const char *file = 0,
                    int line = 0,
                    int maxiter = 0,
                    const ClassDesc *class_desc = 0,
                    const char *exception_type = "MaxIterExceeded") MPQC__NOEXCEPT;
    MaxIterExceeded(const MaxIterExceeded&) MPQC__NOEXCEPT;
    ~MaxIterExceeded() MPQC__NOEXCEPT;
 
    int max_iter() const MPQC__NOEXCEPT { return max_iter_; }
};
 
class ToleranceExceeded: public AlgorithmException {
    double tolerance_;
    double value_;
 
public:
    ToleranceExceeded(const char *description = 0,
                      const char *file = 0,
                      int line = 0,
                      double tol=0,
                      double val=0,
                      const ClassDesc *class_desc = 0,
                      const char *exception_type = "ToleranceExceeded") MPQC__NOEXCEPT;
    ToleranceExceeded(const ToleranceExceeded&) MPQC__NOEXCEPT;
    ~ToleranceExceeded() MPQC__NOEXCEPT;
    double tolerance() MPQC__NOEXCEPT { return tolerance_; }
    double value() MPQC__NOEXCEPT { return value_; }
};
 
// ///////////////////////////////////////////////////////////////////////
// Limit Exceeded Exceptions
 
template <class T>
class LimitExceeded: public SCException {
    T limit_;
    T value_;
 
public:
    LimitExceeded(const char *description,
                  const char *file,
                  int line,
                  T lim,
                  T val,
                  const ClassDesc *class_desc = 0,
                  const char *exception_type = strdup((std::string("LimitExceeded<") + std::string(typeid(T).name()) + std::string(">")).c_str())
                 ) MPQC__NOEXCEPT:
      SCException(description, file, line, class_desc, exception_type),
      limit_(lim), value_(val)
        {
          try {
              elaborate() << "value:       " << value_
                          << std::endl
                          << "limit:       " << limit_
                          << std::endl;
            }
          catch(...) {
            }
        }
    LimitExceeded(const LimitExceeded&ref) MPQC__NOEXCEPT:
      SCException(ref),
      limit_(ref.limit_), value_(ref.value_)
        {
        }
    ~LimitExceeded() MPQC__NOEXCEPT {}
    T tolerance() MPQC__NOEXCEPT { return limit_; }
    T value() MPQC__NOEXCEPT { return value_; }
};
 
class AssertionFailed : public SCException {
 
    const char* assertion_text_;
 
  public:
 
 
    AssertionFailed(const char *assertion_text,
                const char *file,
                int line) MPQC__NOEXCEPT;
 
    const char* assertion_text() const MPQC__NOEXCEPT { return assertion_text_; }
 
};
 
// *    MPQC_ASSERT_* macros.  Don't use it without these macros.
// */
//template<typename T1, typename T2>
//class VerboseAssertionFailed : public AssertionFailed {
 
//    const char* assertion_text_;
 
//  public:
 
//    typedef enum comparison_operator {
//      Not=1,
//      LessThan=2,
//      GreaterThan=4,
//      EqualTo=8,
//      And=16,
//      Or=32
//    };
 
 
//    /** Create an AssertionFailed exception.
 
//        @param the actual code in the assertion
//        @param file the file name where the problem occured.
//        @param line the line number where the exception occured.
 
//        It is suggested that the special macros __FILE__ and __LINE__ be
//        given as the \p file and \p line arguments, respectively.
//    */
//    VerboseAssertionFailed(const char *assertion_text,
//                const char *file,
//                int line) MPQC__NOEXCEPT;
 
//};
 
}
 
#define __scexception_h_finished
#endif