BalauException.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2008 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_EXCEPTION__BALAU_EXCEPTION
#define COM_BORA_SOFTWARE__BALAU_EXCEPTION__BALAU_EXCEPTION

#include <Balau/Type/ToString.hpp>
#include <Balau/Util/Macros.hpp>

#ifdef BALAU_ENABLE_STACKTRACES
    #include <boost/stacktrace.hpp>
    #include <exception>
    #include <Balau/Util/Impl/StringsImpl.hpp>

    #define _ThrowBalauException_generateStackTrace                              \
        std::ostringstream stStream;                                             \
        stStream << boost::stacktrace::stacktrace();                             \
        std::string st = stStream.str();                                         \
        std::string match = std::string(BalauString(BALAU_BASE_FOLDER_)) + "/";  \
        std::string replacement;                                                 \
        ::Balau::Util::Impl::replaceAllImpl(st, match, replacement, nullptr);
#else
    #define _ThrowBalauException_generateStackTrace std::string st;
#endif

#define ThrowBalauException(ExceptionClass, ...) {            \
    _ThrowBalauException_generateStackTrace                   \
    throw ExceptionClass(__FILE__, __LINE__, st, __VA_ARGS__); \
} _Balau_SwallowSemiColon_()

namespace Balau::Exception {

class BalauException : public std::exception {
    public: const std::string message;

    public: const std::string fullMessage;

    public: const char * what() const noexcept override {
        return fullMessage.c_str();
    }

    protected: BalauException(const char * file,
                              int line,
                              const std::string & st,
                              const std::string & name,
                              const std::string & text)
        : message(::toString(name, " - ", text))
        , fullMessage(generateFullMessage(file, line, st, name, text)) {}

    private: static std::string generateFullMessage(const char * file,
                                                    int line,
                                                    const std::string & st,
                                                    const std::string & name,
                                                    const std::string & text) {
        std::ostringstream stream;
        stream << stripFilePath(file) << ":" << line << " - " << name << " - " << text;

        if (!st.empty()) {
            stream << "\n" << st;
        }

        return stream.str();
    }

    // This will need to be reimplemented for the Windows platform.
    private: static std::string stripFilePath(const char * file) {
        const char * lastForward = strrchr(file, '/');

        if (lastForward != nullptr) {
            return std::string(lastForward + 1);
        } else {
            return file;
        }
    }
};

inline bool operator == (const BalauException & lhs, const BalauException & rhs) {
    return typeid(lhs) == typeid(rhs) && lhs.message == rhs.message;
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const BalauException & e) {
    return toString<AllocatorT>(e.fullMessage);
}

inline std::string toString(const BalauException & e) {
    return e.fullMessage;
}

class IllegalArgumentException : public BalauException {
    public: IllegalArgumentException(const char * file, int line, const std::string & st, const std::string & text)
        : BalauException(file, line, st, "IllegalArgument", text) {}
};

class IllegalStateException : public BalauException {
    public: IllegalStateException(const char * file, int line, const std::string & st, const std::string & text)
        : BalauException(file, line, st, "IllegalState", text) {}
};

class UnsupportedOperationException : public BalauException {
    public: UnsupportedOperationException(const char * file, int line, const std::string & st, const std::string & text)
        : BalauException(file, line, st, "UnsupportedOperation", text) {}
};

class NotImplementedException : public BalauException {
    public: NotImplementedException(const char * file, int line, const std::string & st, const std::string & text)
        : BalauException(file, line, st, "NotImplemented", text) {}
};

class ConversionException : public BalauException {
    public: ConversionException(const char * file, int line, const std::string & st, const std::string & text)
        : BalauException(file, line, st, "Conversion", text) {}
};

class BugException : public BalauException {
    public: BugException(const char * file, int line, const std::string & st, const std::string & text)
        : BalauException(file, line, st, "Bug", text) {}
};

} // namespace Balau::Exception

inline std::string toString(const std::exception & e) {
    return e.what();
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const std::exception & e) {
    return toString<AllocatorT>(e.what());
}

#endif // COM_BORA_SOFTWARE__BALAU_EXCEPTION__BALAU_EXCEPTION