b2exception.H

Go to the documentation of this file.

//------------------------------------------------------------------------
// b2exception.H --
//
//
// written by Mathias Doreille
//
// Copyright (c) 2004-2012 SMR Engineering & Development SA
//                         2502 Bienne, Switzerland
//
// All Rights Reserved.  Proprietary source code.  The contents of
// this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior
// written permission of SMR.
//----------------------------------------------------------------------*/
 
#ifndef __B2EXCEPTION_H__
#define __B2EXCEPTION_H__
 
#include <exception>
#include <iostream>
#include <sstream>
#include <string>
 
#include "b2ppconfig.h"
#include "utils/b2util.H"
 
#ifdef HAVE_BACKTRACE
#include <execinfo.h>
 
#include <vector>
#endif
 
extern "C" void b2throw_callback();
 
namespace b2000 {
 
class Exception : public std::exception {
public:
    Exception(const std::string& msg_ = std::string(), const char* file_ = nullptr, int line_ = -1)
        : msg(msg_), file(file_), line(line_) {
#ifdef HAVE_BACKTRACE
        void* bt[128];
        int bt_size = ::backtrace(bt, 128);
        backtrace.insert(backtrace.begin(), bt, bt + bt_size);
#endif
        b2throw_callback();
    }
 
    const char* name() const noexcept { return typeid(Exception).name(); }
 
    virtual const char* get_name() const noexcept { return "Exception"; }
 
    const char* get_file() const { return file ? file : "??"; }
 
    int get_line() const { return line; }
 
    const std::string& get_msg() const { return msg; }
 
    const std::string& get_backtrace(int start_level = 1) const;
 
    ~Exception() noexcept override {}
 
    struct Throw {
        Throw(const char* file_, int line_) : file(file_), line(line_) {}
 
        const char* file;
        int line;
    };
 
    struct Warning {
        Warning(const char* file_, int line_) : file(file_), line(line_) {}
 
        const char* file;
        int line;
    };
 
#define THROW Exception::Throw(__FILE__, __LINE__)
#define WARNING Exception::Warning(__FILE__, __LINE__)
 
    template <typename T>
    Exception& operator<<(const T& t) {
        std::ostringstream o;
        o << t;
        msg += o.str();
        return *this;
    }
 
    template <typename T1, typename T2>
    Exception& operator<<(const std::pair<T1, T2>& t) {
        std::ostringstream o;
        o << "(" << t.first << "," << t.second << ")";
        msg += o.str();
        return *this;
    }
 
    void operator<<(const Throw& t) {
        if (indicate_location) { set_location(t); }
        throw *this;
    }
 
    void operator<<(const Warning& w) {
        std::cerr << "Warning: " << msg;
        if (indicate_location) { std::cerr << " File " << w.file << ":" << w.line; }
        std::cerr << std::endl;
    }
 
#ifdef HAVE_LIB_TBB
    const char* what() const noexcept override { return msg.c_str(); }
 
    Exception* move() noexcept {
        void* e = ::operator new(sizeof(Exception));
        return ::new (e) Exception(*this);
    }
 
    void destroy() noexcept { delete this; }
 
    void throw_self() { throw *this; }
#endif
 
protected:
    void set_msg(const std::string& msg_) { msg = msg_; }
 
    void set_location(const Throw& t) {
        file = t.file;
        line = t.line;
    }
 
    static bool indicate_location;
 
private:
    std::string msg;
    const char* file;
    int line;
#ifdef HAVE_BACKTRACE
    std::vector<void*> backtrace;
#endif
};
 
inline std::ostream& operator<<(std::ostream& out, const Exception& exception) {
    out << exception.get_name() << ": " << exception.get_msg();
    return out;
}
 
template <const char* NAME>
class GenericException : public Exception {
public:
    GenericException(
          const std::string& msg_ = std::string(), const char* file_ = nullptr, int line_ = -1)
        : Exception(msg_, file_, line_) {}
 
    const char* name() const noexcept { return typeid(GenericException).name(); }
 
    const char* get_name() const noexcept override { return NAME; }
 
    template <typename T>
    GenericException& operator<<(const T& t) {
        Exception::operator<<(t);
        return *this;
    }
 
    GenericException& operator<<(const Throw& t) {
        set_location(t);
        throw *this;
        return *this;
    }
 
#ifdef HAVE_LIB_TBB
    GenericException* move() noexcept {
        void* e = ::operator new(sizeof(GenericException));
        return ::new (e) GenericException(*this);
    }
 
    void destroy() noexcept { delete this; }
 
    void throw_self() { throw *this; }
#endif
};
 
extern const char UnimplementedError_name[];
 
typedef GenericException<UnimplementedError_name> UnimplementedError;
 
extern const char KeyError_name[];
 
typedef GenericException<KeyError_name> KeyError;
 
extern const char TypeError_name[];
 
typedef GenericException<TypeError_name> TypeError;
 
extern const char ValueError_name[];
 
typedef GenericException<ValueError_name> ValueError;
 
extern const char IOError_name[];
 
typedef GenericException<IOError_name> IOError;
 
extern const char DBError_name[];
 
typedef GenericException<DBError_name> DBError;
 
extern const char SizeError_name[];
 
typedef GenericException<SizeError_name> SizeError;
 
extern const char ConvergenceError_name[];
typedef GenericException<ConvergenceError_name> ConvergenceError;
 
extern const char OutOfMemoryError_name[];
typedef GenericException<OutOfMemoryError_name> OutOfMemoryError;
 
extern const char KeyboardInterrupt_name[];
typedef GenericException<KeyboardInterrupt_name> KeyboardInterrupt;
 
extern const char SystemError_name[];
typedef GenericException<SystemError_name> SystemError;
 
extern const char LoggingError_name[];
 
typedef GenericException<SystemError_name> LoggingError;
 
extern const char PythonError_name[];
 
typedef GenericException<PythonError_name> PythonError;
 
#ifndef NDEBUG
template <typename R, typename T>
inline R static_cast_check(T t, std::string msg = std::string()) {
    R r = dynamic_cast<R>(t);
    if (r == 0) { TypeError() << msg << THROW; }
    return r;
}
#else
template <typename R, typename T>
inline R static_cast_check(T t, std::string mgs = std::string()) {
    return static_cast<R>(t);
}
#endif
 
}  // namespace b2000
 
#endif /* __B2EXCEPTION_H__ */