---

Err.h

Go to the documentation of this file.

//
// Copyright (C) 2000
// Ralf Westram
// Time-stamp: <Sun Nov/24/2002 18:17 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/
//

#ifndef ERR_H
#define ERR_H

#ifndef RS_ASSERT_H
#include <rs_assert.h>
#endif
#ifndef BOOST_UTIL_H
#include <boost_util.h>
#endif



namespace rs {

    namespace err {

        class Error : public std::runtime_error {
        protected:
            std::string        error_module;
            static std::string module_name;
            bool               real_error;
        public:
            Error(bool real_error_ /*= true*/, const std::string& s);

            Error(const std::string& s);

            Error(bool real_error_ /*= true*/, const char *s);

            Error(const char *s);

            virtual ~Error() throw();

            virtual void print(std::ostream& out) const;

            virtual std::string get_print_message() const;

            virtual const char *what() const throw() { return runtime_error::what(); }

            const char * get_message() const { return what(); }

            static std::string set_module_name(const std::string& new_module_name);

            friend void reThrow(const exception& e);
        };

        /* use this to rethrow an exception that may be an Error.

           Error and derived classes are copied and thrown.
           Other exceptions are thrown as InternalError */
        void reThrow(const std::exception& e);

        // ---------------------------------------------------
        //      class ErrorModule : rs_boost::noncopyable
        // ---------------------------------------------------
        class ErrorModule : rs_boost::noncopyable {
        private:
            std::string old_module_name;

        public:
            explicit ErrorModule(const std::string& new_module_name, bool appendTo=true) {
                old_module_name = Error::set_module_name(new_module_name);
                if (appendTo && !old_module_name.empty()) {
                    Error::set_module_name(old_module_name+"::"+new_module_name);
                }
            }
            ~ErrorModule() {
                Error::set_module_name(old_module_name);
            }
        };


        // --------------------------------------------------------------------------------
        //     class InternalError : public Error
        // --------------------------------------------------------------------------------
        class InternalError : public Error {
        public:
            InternalError(const std::string& s) : Error(s) {
#if !defined(FINAL_VERSION)
                cerr << "Throwing InternalError(" << s << ")\n";
#endif // FINAL_VERSION
            }
            virtual ~InternalError() throw() {}

            virtual std::string get_print_message() const;
        };

        // --------------------------------------------------------------------------------
        //     class IOError : public Error
        // --------------------------------------------------------------------------------
        class IOError : public Error {
        public:
            IOError(const std::string& filename);

            IOError(const std::string& filename, const std::string& IO_command);

            virtual ~IOError() throw() {}
        };

    };
};

#else
#error Err.h included twice
#endif // ERR_H

---

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

(C) 2000-2002