exception.hpp

Go to the documentation of this file.

/*****************************************************************************
    
    exception.hpp -- basic exceptions of library and specific macro for
        asserts.

    This file is a part of the Arageli library.

    Copyright (C) Nikolai Yu. Zolotykh, 1999--2006
    Copyright (C) Sergey S. Lyalin, 2005
    University of Nizhni Novgorod, Russia

*****************************************************************************/

#ifndef _ARAGELI_exception_hpp_
#define _ARAGELI_exception_hpp_

#include "config.hpp"

#include <cstddef>
#include <cassert>
#include <string>
#include <iostream>
#include <sstream>
#include <list>


//****************************************************************************

namespace Arageli
{


class exception
{
public:

    typedef std::list<std::string> descriptions_type;

    exception () {}

    exception (const std::string& description_a)
    : descriptions_m(1, description_a) {}

    const descriptions_type& descriptions () const
    { return descriptions_m; }

    descriptions_type& descriptions ()
    { return descriptions_m; }

    virtual void add_description (const std::string& desc)
    { descriptions_m.push_back(desc); }

    virtual void add_location
    (
        const std::string& src,
        std::size_t line,
        const std::string& desc = std::string()
    );

    virtual std::string msg () const;
    
    virtual void output (std::ostream& out) const { out << msg(); }

    virtual ~exception () {}

private:

    descriptions_type descriptions_m;

};


inline std::ostream& operator<< (std::ostream& out, const exception& e)
{ e.output(out); return out; }


#define ARAGELI_EXCEPT_LOC(e) e.add_location(__FILE__, __LINE__)
#define ARAGELI_EXCEPT_LOC_DESC(e, d) e.add_location(__FILE__, __LINE__, d)

#define ARAGELI_EXCEPT_LOCCTRL_REGION_BEGIN \
    { try {

#define ARAGELI_EXCEPT_LOCCTRL_REGION_END   \
    }catch(::Arageli::exception& e)         \
    { ARAGELI_EXCEPT_LOC_DESC(e, "Exception gate."); throw; } }



class assert_failed : public virtual exception
{
public:

    assert_failed
    (
        const char* expr_a,
        const char* source_a,
        std::size_t line_a
    ) throw()
    :   expr_m(expr_a),
        source_m(source_a),
        line_m(line_a)
    {}

    const char* expr () const throw() { return expr_m; }
    
    const char* source () const throw() { return source_m; }
    
    std::size_t line () const throw() { return line_m; }

    virtual std::string msg () const
    {
        std::ostringstream buf;
        output(buf);
        return buf.str();
    }

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

private:

    const char* expr_m;
    const char* source_m;
    std::size_t line_m;

};


class out_of_range : public virtual exception
{
public:

    virtual std::string msg () const
    {
        return
            "Out of range at an index expression."
            "\nAdditional information:\n" +
            exception::msg();
    }
};


class invalid_argument : public virtual exception
{
public:

    virtual std::string msg () const
    {
        return
            "Invalid argument for the operation"
            "\nAdditional information:\n" +
            exception::msg();
    }
};


class division_by_zero : public invalid_argument
{
public:

    virtual std::string msg () const
    {
        return
            "Division by zero"
            "\nAdditional information:\n" +
            exception::msg();
    }
};


class matrix_is_singular : public invalid_argument
{
public:

    virtual std::string msg () const
    {
        return "Matrix is singular"
            "\nAdditional information:\n" +
            exception::msg();
    }
};


class incorrect_string : public invalid_argument
{
    std::string str_m;

public:

    incorrect_string (const std::string& str_a) : str_m(str_a) {}

    virtual std::string msg () const
    {
        std::string res = "Incorrect string";
        if(!str_m.empty())
            res += " \"" + str_m + "\"";
        return res + "\nAdditional information:\n" + exception::msg();
    }

    const std::string& str () const { return str_m; }

};


namespace ctrl
{

class abort : public virtual exception
{
public:

    virtual std::string msg () const
    {
        return std::string("Controller \"") +
            typeid(*this).name() +
            "\" breaks execution of the function."
            + "\nAdditional information:\n" + exception::msg();
    }
};

}


#ifdef ARAGELI_ASSERT_THROW_EXCEPTION
    #define ARAGELI_THROW_ASSERT_FAILED(EXPR)   \
    { throw ::Arageli::assert_failed(#EXPR, __FILE__, __LINE__); }
#else
    #ifdef NDEBUG
        #define ARAGELI_THROW_ASSERT_FAILED(EXPR)                               \
        {                                                                       \
            ::std::cerr << '\n' << ::Arageli::assert_failed(#EXPR, __FILE__, __LINE__); \
            /*::std::abort();*/::std::cin.get();                                                        \
        }
    #else
        #define ARAGELI_THROW_ASSERT_FAILED(EXPR)   \
        { assert(!#EXPR); }
    #endif
#endif


#define ARAGELI_ASSERT_ALWAYS_CUST(EXPR, EXCEPT_OBJ)    \
    { if(!(EXPR))throw EXCEPT_OBJ; }


#define ARAGELI_ASSERT_ALWAYS(EXPR) \
    { if(!(EXPR))ARAGELI_THROW_ASSERT_FAILED(EXPR); }


#if ARAGELI_DEBUG_LEVEL > 0

    #define ARAGELI_ASSERT_0_CUST(EXPR, EXCEPT_OBJ) \
        ARAGELI_ASSERT_ALWAYS_CUST(EXPR, EXCEPT_OBJ)
    
    #define ARAGELI_ASSERT_0(EXPR)  \
        ARAGELI_ASSERT_ALWAYS(EXPR)

    #define ARAGELI_DEBUG_EXEC_0(WHAT) WHAT

#else

    #define ARAGELI_ASSERT_0_CUST(EXPR, EXCEPT_OBJ) /* nothing */
    #define ARAGELI_ASSERT_0(EXPR)  /* nothing */
    #define ARAGELI_DEBUG_EXEC_0(WHAT)  /* nothing */

#endif


#if ARAGELI_DEBUG_LEVEL > 1

    #define ARAGELI_ASSERT_1_CUST(EXPR, EXCEPT_OBJ) \
        ARAGELI_ASSERT_ALWAYS_CUST(EXPR, EXCEPT_OBJ)
    
    #define ARAGELI_ASSERT_1(EXPR)  \
        ARAGELI_ASSERT_ALWAYS(EXPR)

    #define ARAGELI_DEBUG_EXEC_1(WHAT) WHAT

#else

    #define ARAGELI_ASSERT_1_CUST(EXPR, EXCEPT_OBJ) /* nothing */
    #define ARAGELI_ASSERT_1(EXPR) /* nothing */
    #define ARAGELI_DEBUG_EXEC_1(WHAT)  /* nothing */

#endif


#if ARAGELI_DEBUG_LEVEL > 2

    #define ARAGELI_ASSERT_2_CUST(EXPR, EXCEPT_OBJ) \
        ARAGELI_ASSERT_ALWAYS_CUST(EXPR, EXCEPT_OBJ)
    
    #define ARAGELI_ASSERT_2(EXPR)  \
        ARAGELI_ASSERT_ALWAYS(EXPR)

    #define ARAGELI_DEBUG_EXEC_2(WHAT) WHAT

#else

    #define ARAGELI_ASSERT_2_CUST(EXPR, EXCEPT_OBJ) /* nothing */
    #define ARAGELI_ASSERT_2(EXPR) /* nothing */
    #define ARAGELI_DEBUG_EXEC_2(WHAT)  /* nothing */

#endif


#if ARAGELI_DEBUG_LEVEL > 3

    #define ARAGELI_ASSERT_3_CUST(EXPR, EXCEPT_OBJ) \
        ARAGELI_ASSERT_ALWAYS_CUST(EXPR, EXCEPT_OBJ)
    
    #define ARAGELI_ASSERT_3(EXPR)  \
        ARAGELI_ASSERT_ALWAYS(EXPR)

    #define ARAGELI_DEBUG_EXEC_3(WHAT) WHAT

#else

    #define ARAGELI_ASSERT_3_CUST(EXPR, EXCEPT_OBJ) /* nothing */
    #define ARAGELI_ASSERT_3(EXPR) /* nothing */
    #define ARAGELI_DEBUG_EXEC_3(WHAT)  /* nothing */

#endif


} // namespace Arageli


#endif  //  #ifndef _ARAGELI_exception_hpp_

---