l_exception.h

Go to the documentation of this file.

/*
 * $Id: l_exception.h 18250 2014-11-20 00:55:38Z ksimek $
 */

/* =========================================================================== *
|
|  Copyright (c) 1994-2010
|
|  Personal and educational use of this code is granted, provided that this
|  header is kept intact, and that the authorship is not misrepresented, that
|  its use is acknowledged in publications, and relevant papers are cited.
|
|  For other use contact the author (kobus AT cs DOT arizona DOT edu).
|
|  Please note that the code in this file has not necessarily been adequately
|  tested. Naturally, there is no guarantee of performance, support, or fitness
|  for any particular task. Nonetheless, I am interested in hearing about
|  problems that you encounter.
|
| Authors:
|    Kobus Barnard, Kyle Simek, Joseph Schlecht, Luca Del Pero, Andrew Predoehl
|
* =========================================================================== */

#ifndef KJB_EXCEPTION_H
#define KJB_EXCEPTION_H

#include <l/l_sys_err.h>
#include <l/l_sys_str.h>
#include <l/l_string.h>
#include <boost/preprocessor/seq.hpp>
#include <exception>
#include <string>
#include <iosfwd>

#define KJB_THROW(ex) throw ex(__FILE__, __LINE__)

#define KJB_THROW_2(ex, msg) throw ex(msg, __FILE__, __LINE__)

/*
 * The do { ... } while(0) structure below avoids the mistake known as
 * "swallowing the semicolon."
 */

// usage: KJB_THROW_3(Exception, format_string, (param1)(param2)(param3)(...))
#define KJB_THROW_3(ex, fmt, params)                            \
    do                                                          \
    {                                                           \
        char buffer[ERROR_MESS_BUFF_SIZE];                      \
        kjb_c::kjb_sprintf(buffer, ERROR_MESS_BUFF_SIZE, fmt,   \
                            BOOST_PP_SEQ_ENUM(params));         \
        throw ex(buffer, __FILE__, __LINE__);                   \
    }                                                           \
    while(0)

// "On error throw exception" -- in this case, "error" is ANY nonzero value.
#define ETX(a)                                                  \
    do                                                          \
    {                                                           \
        if (a)                                                  \
        {                                                       \
            kjb::throw_kjb_error( "", __FILE__, __LINE__ );     \
        }                                                       \
    }                                                           \
    while(0)


#define ETX_2(a, msg)                                           \
    do                                                          \
    {                                                           \
        if (a)                                                  \
        {                                                       \
            kjb::throw_kjb_error(msg, __FILE__, __LINE__);      \
        }                                                       \
    }                                                           \
    while(0)

// "On null throw exception"
#define NTX(a)                                                  \
    do                                                          \
    {                                                           \
        if ((a) == NULL)                                        \
        {                                                       \
            kjb::throw_kjb_error( "Null result",                \
                                        __FILE__, __LINE__ );   \
        }                                                       \
    }                                                           \
    while(0)

// "If False Throw (exception)" -- throws 'ex' if 'a' is false.
#define IFT(a, ex, msg)                                         \
    do                                                          \
    {                                                           \
        if(!(a))                                                \
        {                                                       \
            KJB_THROW_2(ex, msg);                               \
        }                                                       \
    }                                                           \
    while(0)                                                    \

// "If False Throw (exception) with details" -- throws 'ex' if 'a' is false.
#define IFTD(a, ex, msg, params)                                \
    do                                                          \
    {                                                           \
        if(!(a))                                                \
        {                                                       \
            KJB_THROW_3(ex, msg, params);                       \
        }                                                       \
    }                                                           \
    while(0)                                                    \




namespace kjb {

class Exception  : public std::exception
{
public:

    Exception(const char* msg, const char* file=0, unsigned line=0);


    Exception(const std::string& msg, const char* file=0, unsigned line=0);

    Exception(const Exception& e);


    virtual ~Exception() throw() { }


    const std::string& get_msg() const throw()
    {
        return m_msg;
    }

    const char* what() const throw()
    {
        return m_msg.c_str();
    }


    const char* get_file() const
    {
        return m_file;
    }


    unsigned get_line() const
    {
        return m_line;
    }

    std::string get_details() const;


    virtual void print(
        std::ostream& out, // = std::cerr
        bool newline = false
    )   const;

    virtual void print() const;



    virtual void print_details(
        std::ostream& out, // = std::cerr
        bool newline = false
    )   const;

    virtual void print_details() const;

    virtual void print_abort(
        std::ostream& out, // = std::cerr
        bool newline = false
    )   const;

    virtual void print_abort() const; 

    virtual void print_details_abort
    (
        std::ostream& out, // = std::cerr
        bool     newline = false
    )
    const;

    virtual void print_details_abort() const;


    virtual void print_exit
    (
        std::ostream& out,
        bool     newline, // = std::cerr
        int      status = false
    )
    const;

    virtual void print_exit() const;


    virtual void print_details_exit
    (
        std::ostream& out, 
        bool     newline = false,
        int      status = EXIT_FAILURE
    )
    const;

    virtual void print_details_exit() const;


protected:

    std::string m_msg;

    const char* m_file;

    unsigned m_line;
};


class KJB_error : public Exception
{
public:
    KJB_error(const char* msg, const char* file=0, unsigned line=0);


    KJB_error(const std::string& msg, const char* file=0, unsigned line=0);


    virtual ~KJB_error() throw() { }

};



class Not_implemented : public Exception
{
public:
    Not_implemented(const char* file, unsigned line);

    Not_implemented(const char* msg, const char* file=0, unsigned line=0);


    Not_implemented(
        const std::string& msg,
        const char* file=0,
        unsigned line=0
    );


    virtual ~Not_implemented() throw() { }

};

class Runtime_error : public Exception
{
public:
    Runtime_error(const char* file, unsigned line);

    Runtime_error(const char* msg, const char* file=0, unsigned line=0);


    Runtime_error(
        const std::string& msg,
        const char* file=0,
        unsigned line=0
    );

    virtual ~Runtime_error() throw() { }

};

class Cant_happen : public Exception
{
public:
    Cant_happen(const char* file, unsigned line);

    Cant_happen(const char* msg, const char* file=0, unsigned line=0);

    Cant_happen(const std::string& msg, const char* file=0, unsigned line=0);

    virtual ~Cant_happen() throw() { }

};


class Illegal_argument : public Runtime_error
{
public:
    Illegal_argument(const char* file, unsigned line);

    Illegal_argument(const char* msg, const char* file=0, unsigned line=0);

    Illegal_argument(
        const std::string& msg,
        const char* file=0,
        unsigned line=0
    );

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


class Index_out_of_bounds : public Illegal_argument
{
public:
    Index_out_of_bounds(const char* file, unsigned line);

    Index_out_of_bounds(const char* msg, const char* file=0, unsigned line=0);


    Index_out_of_bounds(
        const std::string& msg,
        const char* file=0,
        unsigned line=0
    );


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


class Dimension_mismatch : public Illegal_argument
{
public:
    Dimension_mismatch(const char* file, unsigned line);

    Dimension_mismatch(const char* msg, const char* file=0, unsigned line=0);


    Dimension_mismatch(
        const std::string& msg,
        const char* file=0,
        unsigned line=0
    );

    virtual ~Dimension_mismatch() throw() { }

};


class Divide_by_zero : public Runtime_error
{
public:
    Divide_by_zero(const char* file, unsigned line);

    Divide_by_zero(const char* msg, const char* file=0, unsigned line=0);


    Divide_by_zero(
        const std::string& msg,
        const char* file=0,
        unsigned line=0
    );

    virtual ~Divide_by_zero() throw() { }

};

class Serialization_error : public Runtime_error
{
public:
    Serialization_error(const char* file, unsigned line);

    Serialization_error(const char* msg, const char* file=0, unsigned line=0);


    Serialization_error(
        const std::string& msg,
        const char* file=0,
        unsigned line=0
    );

    virtual ~Serialization_error() throw() { }

};

class IO_error : public Exception
{
public:
    IO_error(const char* file, unsigned line);

    IO_error(const char* msg, const char* file=0, unsigned line=0);


    IO_error(const std::string& msg, const char* file=0, unsigned line=0);


    virtual ~IO_error() throw() { }

};

class Result_error : public Exception
{
public:
    Result_error(const char* file, unsigned line);

    Result_error(const char* msg, const char* file=0, unsigned line=0);


    Result_error(const std::string& msg, const char* file=0, unsigned line=0);


    virtual ~Result_error() throw() { }

};

class Missing_dependency : public Exception
{
public:
    Missing_dependency(const char* file, unsigned line);

    Missing_dependency(
        const char* dependency,
        const char* file=0,
        unsigned line=0
    );


    Missing_dependency(
        const std::string& dependency,
        const char* file=0,
        unsigned line=0
    );


    virtual ~Missing_dependency() throw() { }

};

class Option_exception : public Exception
{
public:
    Option_exception(
        const std::string& msg,
        const char* file=0,
        unsigned line=0
    );

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

class Missing_option : public Option_exception
{
public:
    Missing_option(
        const std::string& option,
        const char* file=0,
        unsigned line=0
    );

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

typedef Cant_happen Cant_happen_exception;
#if 0
class Cant_happen_exception : public Runtime_error
{
public:
    Cant_happen_exception(const char* file=0, unsigned line=0);

    virtual ~Cant_happen_exception() { } throw()
};
#endif

class Stack_overflow : public Runtime_error
{
public:
    Stack_overflow(const char* file=0, unsigned line=0);

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

class Stack_underflow : public Runtime_error
{
public:
    Stack_underflow(const char* file=0, unsigned line=0);

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


class Resource_exhaustion : public Runtime_error
{
public:
    Resource_exhaustion(const char* file=0, unsigned line=0)
    :   Runtime_error("Resource exhaustion", file, line)
    {}

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


std::string kjb_get_error();

void throw_kjb_error( const char* msg, const char* file, unsigned line);

} // namespace kjb


#endif