Exceptions.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_EXCEPTIONS_H_
#define _MIRA_EXCEPTIONS_H_

#include <error/Exception.h>
#include <factory/Factory.h>

#define MIRA_DEFINE_SERIALIZABLE_EXCEPTION(Ex, Base)                             \
    class Ex : public Base                                                       \
    {                                                                            \
        MIRA_OBJECT(Ex)                                                          \
    protected:                                                                   \
        friend class mira::ClassFactoryDefaultConstClassBuilder;                 \
        Ex() MIRA_NOEXCEPT_OR_NOTHROW {}                                         \
                                                                                 \
    public:                                                                      \
        Ex(std::string msg, const char* file=NULL, int line=0) MIRA_NOEXCEPT_OR_NOTHROW :  \
            Base(std::move(msg), file, line) {}                                  \
        /* The exception object is copy-initialized from *this; */               \
        void raise(bool recursive = false) override { throw *this; }             \
    };

namespace mira {


class SerializableException : public Object, public Exception
{
    MIRA_ABSTRACT_OBJECT(SerializableException)

protected:
    friend class ClassFactoryDefaultConstClassBuilder;
    SerializableException() {}

public:
    SerializableException(const std::string& msg, const char* file=NULL, int line=0) MIRA_NOEXCEPT_OR_NOTHROW :
        Exception(msg, file, line) {}

    virtual ~SerializableException() MIRA_NOEXCEPT_OR_NOTHROW {}

    MIRA_SPLIT_REFLECT_MEMBER

    // We directly include serialization of base class elements here and only use most basic serialization
    // features, as things that we would like to use like serialization/ReflectorInterface.h and
    // serialization/adapters/std/list depend (indirectly) on the exceptions we will define below.
    template<typename Reflector>
    void reflectRead(Reflector& r) {
        uint32 count = mInfos.size();
        r.member("InfoCount", count, "Number of info fields");
        uint64 n = 0;
        for (const auto& i : mInfos) {
            r.member(("Info"+std::to_string(n)+"Message").c_str(), i.message, "Message");
            r.member(("Info"+std::to_string(n)+"File").c_str(),    i.file,    "File");
            r.member(("Info"+std::to_string(n)+"Line").c_str(),    i.line,    "Line");
            ++n;
        }
        r.member("Stack",    mStack,    "Call stack");
        r.member("ThreadID", mThreadID, "Thread ID");
    }

    template<typename Reflector>
    void reflectWrite(Reflector& r) {
        uint32 count;
        r.member("InfoCount", count, "Number of info fields");
        std::string message;
        std::string file;
        int line;
        for (uint64 n = 0; n < count; ++n) {
            r.member(("Info"+std::to_string(n)+"Message").c_str(), message, "Message");
            r.member(("Info"+std::to_string(n)+"File").c_str(),    file,    "File");
            r.member(("Info"+std::to_string(n)+"Line").c_str(),    line,    "Line");
            mInfos.emplace_back(std::move(message), std::move(file), line);
        }

        r.member("Stack",    mStack,    "Call stack");
        r.member("ThreadID", mThreadID, "Thread ID");
    }

    // C++ does not support polymorphic throw, i.e. throwing a base class reference that holds a subclass object
    // will invoke the base class catch clause. Therefore we need to do the throw in a virtual method.
    virtual void raise(bool recursive = false) = 0;
};

typedef boost::shared_ptr<SerializableException> SerializableExceptionPtr;

MIRA_DEFINE_SERIALIZABLE_EXCEPTION(XRuntime, SerializableException)


MIRA_DEFINE_SERIALIZABLE_EXCEPTION(XInvalidConfig, XRuntime)


MIRA_DEFINE_SERIALIZABLE_EXCEPTION(XIO, XRuntime)


MIRA_DEFINE_SERIALIZABLE_EXCEPTION(XConnection, XRuntime)


MIRA_DEFINE_SERIALIZABLE_EXCEPTION(XSystemCall, XRuntime)


MIRA_DEFINE_SERIALIZABLE_EXCEPTION(XFileNotFound, XIO)


MIRA_DEFINE_SERIALIZABLE_EXCEPTION(XNotImplemented, XRuntime)


MIRA_DEFINE_SERIALIZABLE_EXCEPTION(XTimeout, XRuntime)


MIRA_DEFINE_SERIALIZABLE_EXCEPTION(XLogical, SerializableException)


MIRA_DEFINE_SERIALIZABLE_EXCEPTION(XInvalidParameter, XLogical)


MIRA_DEFINE_SERIALIZABLE_EXCEPTION(XAssertion, XLogical)


MIRA_DEFINE_SERIALIZABLE_EXCEPTION(XBadCast, XRuntime)


MIRA_DEFINE_SERIALIZABLE_EXCEPTION(XAccessViolation, XRuntime)


MIRA_DEFINE_SERIALIZABLE_EXCEPTION(XBadAlloc, SerializableException)


}

#endif