---

Err.cpp

Go to the documentation of this file.

//
// Copyright (C) 2000
// Ralf Westram
// Time-stamp: <Fri Nov/29/2002 12:46 MET Coder@ReallySoft.de>
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation.  Ralf Westram makes no
// representations about the suitability of this software for any
// purpose.  It is provided "as is" without express or implied warranty.
//
// This code is part of my library.
// You may find a more recent version at http://www.reallysoft.de/
//

#include <Err.h>
#include <Tools.h>
#include <cerrno>

using namespace std;
using namespace rs;
using namespace rs::str;
using namespace rs::err;

string Error::module_name = "<unknown>";

#if defined(DUMP)
// #define DUMP_ERRORS
#endif // DUMP

// --------------------------------------------------------
//      Error::Error(bool real_error_, const string& s)
// --------------------------------------------------------
Error::Error(bool real_error_, const string& s)
    : runtime_error(s)
    , error_module(module_name)
    , real_error(real_error_)
{
#if defined(DUMP_ERRORS)
    cout << "Error(" << s << ")\n";
#endif // DUMP_ERRORS
}
// --------------------------------------
//      Error::Error(const string& s)
// --------------------------------------
Error::Error(const string& s)
    : runtime_error(s)
    , error_module(module_name)
    , real_error(true)
{
#if defined(DUMP_ERRORS)
    cout << "Error(" << s << ")\n";
#endif // DUMP_ERRORS
}
// ------------------------------------------------------
//      Error::Error(bool real_error_, const char *s)
// ------------------------------------------------------
Error::Error(bool real_error_, const char *s)
    : runtime_error(s)
    , error_module(module_name)
    , real_error(real_error_)
{
#if defined(DUMP_ERRORS)
    cout << "Error(" << s << ")\n";
#endif // DUMP_ERRORS
}
// ------------------------------------------------------
//      Error::Error(bool real_error_, const char *s)
// ------------------------------------------------------
Error::Error(const char *s)
    : runtime_error(s)
    , error_module(module_name)
    , real_error(true)
{
#if defined(DUMP_ERRORS)
    cout << "Error(" << s << ")\n";
#endif // DUMP_ERRORS
}

namespace rs {
    namespace err {
        //  -----------------------------------------
        //      void reThrow(const exception& e)
        //  -----------------------------------------
        void reThrow(const exception& e) {
            const Error *is_err = dynamic_cast<const Error*>(&e);
            if (is_err) throw *is_err;

            const char *kind_of = "exception";
            const logic_error *is_logic = dynamic_cast<const logic_error*>(&e);
            if (is_logic) {
                kind_of = "logic_error";
                const domain_error *is_domain = dynamic_cast<const domain_error*>(is_logic);
                if (is_domain) {
                    kind_of = "domain_error";
                }
                else {
                    const invalid_argument *is_inv_arg = dynamic_cast<const invalid_argument*>(is_logic);
                    if (is_inv_arg) {
                        kind_of = "invalid_argument";
                    }
                    else {
                        const length_error *is_length = dynamic_cast<const length_error*>(is_logic);
                        if (is_length) {
                            kind_of = "length_error";
                        }
                        else {
                            const out_of_range *is_outof = dynamic_cast<const out_of_range*>(is_length);
                            if (is_outof) kind_of = "out_of_range";
                        }
                    }
                }
            }
            else {
                const runtime_error *is_runtime = dynamic_cast<const runtime_error*>(&e);
                if (is_runtime) {
                    kind_of = "runtime_error";
                    const range_error *is_range = dynamic_cast<const range_error*>(is_runtime);
                    if (is_range) {
                        kind_of = "range_error";
                    }
                    else {
                        const overflow_error *is_overflow = dynamic_cast<const overflow_error*>(is_runtime);
                        if (is_overflow) {
                            kind_of = "overflow_error";
                        }
                        else {
                            const underflow_error *is_underflow = dynamic_cast<const underflow_error*>(is_runtime);
                            if (is_underflow) kind_of = "underflow_error";
                        }
                    }
                }
            }

            throw InternalError(string("[")+kind_of+": "+e.what()+']');
        }
    };
};

// ---------------------------------
//      Error::~Error() throw()
// ---------------------------------
Error::~Error() throw() {
}

//  ----------------------------------------------
//      void Error::print(ostream& out) const
//  ----------------------------------------------
void Error::print(ostream& out) const {
    out << "\n"
        << get_print_message() << "\n";
}

//  ------------------------------------------------
//      string Error::get_print_message() const
//  ------------------------------------------------
string Error::get_print_message() const {
    if (real_error) return str::strf("Error in %s: %s", error_module.c_str(), what());
    return str::strf("%s: %s", error_module.c_str(), what());
}

//  --------------------------------------------------------
//      string InternalError::get_print_message() const
//  --------------------------------------------------------
string InternalError::get_print_message() const {
    return str::strf("InternalError in %s: %s\n[please report to %s]",
                     error_module.c_str(),
                     what(),
                     MAIL_CONTACT(module_name+".BugReport").c_str());
}

//  ---------------------------------------------------------------------
//      string Error::set_module_name(const string& new_module_name)
//  ---------------------------------------------------------------------
string Error::set_module_name(const string& new_module_name) {
    string old_module_name = module_name;
    module_name = new_module_name;
    return old_module_name;
}

//  ------------------------------------------------
//      IOError::IOError(const string& filename)
//  ------------------------------------------------
IOError::IOError(const string& filename)
    : Error(string(strerror(errno)) + " ('" + filename + "')")
{
}

//  -----------------------------------------------------------------------
//      IOError::IOError(const string& filename, const string& command)
//  -----------------------------------------------------------------------
IOError::IOError(const string& filename, const string& command)
    : Error(string(strerror(errno)) + " for " + command+ " ('" + filename + "')")
{
}

---

Contact me in case of errors or questions. This documentation is powered by .

(C) 2000-2002