Exception.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_EXCEPTION_H_
#define _MIRA_EXCEPTION_H_

#include <assert.h>

#include <string.h>

#include <exception>
#include <sstream>

#include <list>

#include <error/CallStack.h>
#include <thread/ThreadID.h>
#include <utils/NoExcept.h>
#include <utils/PathFinderConstExpr.h>


#define MIRA_THROW(ex, msg)                                         \
{                                                                   \
    std::ostringstream ex_str;                                      \
    ex_str << msg;                                                  \
    constexpr auto fileInMIRAPath = mira::chopMIRAPath(__FILE__);   \
    throw ex(ex_str.str(), fileInMIRAPath, __LINE__).addStackInfo<ex>();  \
}

#define MIRA_THROW_NOSTACK(ex, msg)              \
{                                                \
    std::ostringstream ex_str;                   \
    ex_str << msg;                               \
    constexpr auto fileInMIRAPath = mira::chopMIRAPath(__FILE__); \
    throw ex(ex_str.str(), fileInMIRAPath, __LINE__);  \
}

#define MIRA_THROW_EXTSTACK(ex, msg, stack, thread)  \
{                                                    \
    std::ostringstream ex_str;                       \
    ex_str << msg;                                   \
    constexpr auto fileInMIRAPath = mira::chopMIRAPath(__FILE__); \
    throw ex(ex_str.str(), fileInMIRAPath, __LINE__)       \
        .addExternalStackInfo<ex>(stack, thread);    \
}

#define MIRA_RETHROW(ex, msg)                    \
{                                                \
    std::ostringstream ex_str;                   \
    ex_str << msg;                               \
    constexpr auto fileInMIRAPath = mira::chopMIRAPath(__FILE__); \
    ex.addInfo(ex_str.str(),fileInMIRAPath, __LINE__); \
    throw; /* rethrow */                         \
}

#define MIRA_DEFINE_EXCEPTION(Ex, Base)                                        \
    class Ex : public Base                                                     \
    {                                                                          \
    public:                                                                    \
        Ex(std::string msg, const char* file=NULL, int line=0) MIRA_NOEXCEPT_OR_NOTHROW : \
            Base(std::move(msg), file, line) {}                                \
                                                                               \
        virtual ~Ex() MIRA_NOEXCEPT_OR_NOTHROW {}                              \
    };


namespace mira {


class MIRA_BASE_EXPORT Exception : public std::exception
{
protected:
    Exception() MIRA_NOEXCEPT_OR_NOTHROW {}

public:

    Exception(std::string message, const char* file=NULL, int line=0) MIRA_NOEXCEPT_OR_NOTHROW
    {
        addInfo(std::move(message), file, line);
    }

    virtual ~Exception() MIRA_NOEXCEPT_OR_NOTHROW {}

    void addInfo(std::string message, const char* file=NULL, int line=0)
    {
        mInfos.emplace_back(std::move(message), file ? std::string(file) : "", line);
    }

    virtual const char* what() const MIRA_NOEXCEPT_OR_NOTHROW;


    std::string message() const MIRA_NOEXCEPT_OR_NOTHROW;

    const CallStack& callStack() const { return mStack; }


    ThreadID getThreadID() const { return mThreadID; }

public:

    template <typename DerivedException>
    DerivedException& addStackInfo()
    {
        // save the call stack:
        mStack = createCallStack();
        mThreadID = getCurrentThreadID();
        return (DerivedException&)*this;
    }

    template <typename DerivedException>
    DerivedException& addExternalStackInfo(CallStack stack, ThreadID thread)
    {
        mStack = std::move(stack);
        mThreadID = thread;
        return (DerivedException&)*this;
    }

private:

    CallStack createCallStack();

public:

    struct Info {
        std::string message;   
        std::string file;      
        int         line;      

    public:
        Info(std::string iMessage, std::string iFile, int iLine) :
            message(std::move(iMessage)), file(std::move(iFile)), line(iLine) {}

        std::string what(std::size_t messageWidth) const;
    };


    const Info& getInfo() const { assert(!mInfos.empty()); return mInfos.front(); }

protected:
    std::list<Info> mInfos;
    CallStack       mStack;
    ThreadID        mThreadID;
    mutable std::string mMessage; 
};


}

#endif