Exception.hh

Go to the documentation of this file.

//
// Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
//                    Network Research Group (NET)
//                    Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
//                    Contact: support@wiback.org
//
// This file is part of the SENF code tree.
// It is licensed under the 3-clause BSD License (aka New BSD License).
// See LICENSE.txt in the top level directory for details or visit
// https://opensource.org/licenses/BSD-3-Clause
//


#ifndef HH_SENF_Utils_Exception_
#define HH_SENF_Utils_Exception_ 1

// Custom includes
#include <exception>
#include <stdexcept>
#include <string>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <senf/config.hh>

//#include "Exception.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {

    class ExceptionMixin
    {
    public:
        std::string message() const; 
        std::string backtrace() const; 

        void append(std::string text);  

    protected:
        explicit ExceptionMixin(std::string const & description = "");

        std::string what_;

    private:
#ifdef SENF_BACKTRACE
        void addBacktrace();
        std::string::size_type excLen_;
#endif
    };

    class Exception
        : public ExceptionMixin, public std::exception
    {
    public:
        virtual ~Exception() throw();

        virtual char const * what() const throw();

    protected:
        explicit Exception(std::string const & description = "");
    };

    template <class BaseException>
    class WrapException
        : public ExceptionMixin, public BaseException
    {
    public:
        typedef BaseException Base;

        WrapException(BaseException const & base);
        virtual ~WrapException() throw();

        virtual char const * what() const throw();
    };

    template <class BaseException>
    WrapException<BaseException> make_WrapException(BaseException const & base);


    struct InvalidArgumentException
        : public WrapException<std::invalid_argument>
    {
        InvalidArgumentException(std::string const & what_arg);
    };


#   define SENF_WRAP_EXC(Ex)                                                                      \
        catch (Ex const & base) {                                                                 \
            if (dynamic_cast<senf::ExceptionMixin const *>(&base))                                \
                throw;                                                                            \
            else                                                                                  \
                throw senf::WrapException<Ex>(base);                                              \
        }

#   define SENF_WRAP_EXC_MSG(Ex, Msg)                                                             \
        catch (Ex const & base) {                                                                 \
            if (dynamic_cast<senf::ExceptionMixin const *>(&base))                                \
                throw;                                                                            \
            else                                                                                  \
                throw senf::WrapException<Ex>(base) << " " << Msg;                                \
        }

    template <class Exc, class Arg>
    typename boost::enable_if< boost::is_convertible<Exc*,ExceptionMixin*>, Exc & >::type
    operator<<(Exc const & exc, Arg const & arg); 

#   ifdef SENF_DEBUG
#       define _SENF_EXC_DEBUG_ARGS ,char const * file=0,int line=0
#       define _SENF_EXC_DEBUG_ARGS_ND ,char const *file,int line
#       define _SENF_EXC_DEBUG_ARGS_P ,file,line
#   else
#       define _SENF_EXC_DEBUG_ARGS
#       define _SENF_EXC_DEBUG_ARGS_ND
#       define _SENF_EXC_DEBUG_ARGS_P
#   endif

    class SystemException : public Exception
    {
    public:
        //-////////////////////////////////////////////////////////////////////////
        //\{

        explicit SystemException(std::string const & descr = "" _SENF_EXC_DEBUG_ARGS);
        explicit SystemException(int code _SENF_EXC_DEBUG_ARGS);
        SystemException(std::string const & descr, int code _SENF_EXC_DEBUG_ARGS);

        virtual ~SystemException() throw();

        //\}
        //-////////////////////////////////////////////////////////////////////////

        int errorNumber() const;        
        char const * errorString() const; 

        bool anyOf(int c0, int c1=0, int c2=0, int c3=0, int c4=0, int c5=0,
                   int c6=0, int c7=0, int c8=0, int c9=0) const;

    private:
        void init(std::string const & descr, int code _SENF_EXC_DEBUG_ARGS_ND);

        int code_;
    };

#   ifdef SENF_DEBUG
#       define SENF_EXC_DEBUGINFO ,__FILE__,__LINE__
#   else
#       define SENF_EXC_DEBUGINFO
#   endif

#   define SENF_THROW_SYSTEM_EXCEPTION(desc)                    \
        throw senf::SystemException(desc SENF_EXC_DEBUGINFO)

}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "Exception.cci"
//#include "Exception.ct"
#include "Exception.cti"
#endif


// Local Variables:
// mode: c++
// fill-column: 100
// c-file-style: "senf"
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
// compile-command: "scons -u test"
// comment-column: 40
// End: