error.h

Go to the documentation of this file.

#ifndef __error_h__
#define __error_h__

#include <iostream>
#include <string>
#include <algorithm>
#include <exception>
#include <vector>

#include <cerrno>

#include "asserts.h"
#include "types.h"

/** Instance of a single error containing a descriptive error message and the
 * location in the file that the error took place */
class error_instance
{
public:
        error_instance();
        error_instance(const error_instance& a_e);
        error_instance(
                const std::string a_what,
#ifdef __GNUC__
                const std::string a_where,
#endif
                const std::string a_file,
                const uint16 a_line
                );

        void clear(void);
        void set(void);
        void set(const error_instance& a_e);
        void set(
                const std::string a_what,
#ifdef __GNUC__
                const std::string a_where,
#endif
                const std::string a_file,
                const uint16 a_line
                );

        const std::string what(void) const;
#ifdef __GNUC__
        const std::string where(void) const;
#endif
        const std::string file(void) const;
        const uint16 line(void) const;

        error_instance& operator=(const error_instance& a_e);

        // void dump(std::ostream& a_out, const std::string& a_prefix) const;

private:
        std::string m_what;
#ifdef __GNUC__
        std::string m_where;
#endif
        std::string m_file;
        uint16 m_line;
};

#ifdef __GNUC__
#define ERROR_INSTANCE(s) \
        error_instance((s), __PRETTY_FUNCTION__, __FILE__, __LINE__)
#else
#define ERROR_INSTANCE(s) \
        error_instance((s), __FILE__, __LINE__)
#endif

/** An error class */
class error : public std::vector<error_instance>
{
public:
        typedef std::vector<error_instance> type;

        error(const int a_errno);
        error(
                const int a_errno,
                const error_instance& a_e, 
                const bool a_internal = false
                );
        error(const error& a_e);

        void clear(void);
        void clear_stack(void);
        void internal(bool a_i);
        const bool internal(void) const;
        void num(int a_i);
        int num(void) const;
        void push_back(const error_instance& a_e);
        void push_back(const std::string& a_str);
        void assign(const error& a_e);

        error& operator=(const error& a_e);
        std::ostream& write(
                std::ostream& a_out, 
                const std::string a_prefix = ""
                ) const;
        const std::string str(const std::string a_prefix = "") const;

        // std::ostream& dump(std::ostream& a_out) const;

private:
        int m_errno;
        bool m_internal;
};

std::ostream& operator<<(std::ostream& a_out, const error& a_e);

//-----------------------------------------------------------------------------

#define err_unknown INTERNAL_ERROR(0,"An unknown error has occured")

#define err_nomem ERROR(ENOMEM,"Out of memory")

//-----------------------------------------------------------------------------

#define ERROR(e,s) \
        error(e,ERROR_INSTANCE((s)), false)

#define INTERNAL_ERROR(e,s) \
        error(e,ERROR_INSTANCE(s), true)

#define TRY(code,es) \
        try { \
                code; \
        } \
        catch(error e) { \
                e.push_back(ERROR_INSTANCE(es)); \
                throw(e); \
        } \
        catch(...) { \
                if (errno == ENOMEM) { \
                        throw(err_nomem); \
                } \
                error e = err_unknown; \
        \
                e.push_back(es); \
                throw(e); \
        }

#define TRY_nomem(code) \
        try { \
                code; \
        } \
        catch(error e) { \
                throw(e); \
        } \
        catch(...) { \
                if (errno == ENOMEM) { \
                        throw(err_nomem); \
                } \
                throw(err_unknown); \
        }

#define TRY_instead(code,es) \
        try { \
                code; \
        } \
        catch(error e) { \
                e.clear_stack(); \
                e.push_back(ERROR_INSTANCE(es)); \
                throw(e); \
        } \
        catch(...) { \
                if (errno == ENOMEM) { \
                        throw(err_nomem); \
                } \
                error e = err_unknown; \
        \
                e.push_back(es); \
                throw(e); \
        }

#define TRY_log(code,es) \
        try { \
                code; \
        } \
        catch(error e) { \
                e.clear_stack(); \
                e.push_back(ERROR_INSTANCE(es)); \
                logger.write(e.str()); \
        } \
        catch(...) { \
                if (errno == ENOMEM) { \
                        throw(err_nomem); \
                } \
                error e = err_unknown; \
        \
                e.push_back(es); \
                logger.write(e.str()); \
        }

const char * get_error_str(const int a_err);

#endif

---