exceptions.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_EXCEPTIONS_HPP
#define RTCTK_COMPONENTFRAMEWORK_EXCEPTIONS_HPP
 
#include <string_view>
#include <type_traits>
#include <typeinfo>
 
#include <ciiBasicDataType.hpp>
#include <ciiException.hpp>
 
namespace {
 
// Constructs an exception object. Depending on the type of the exception, additional context
// information is added to the object if supported.
// This function is used to implement the CII_THROW and CII_THROW_WITH_NESTED macros.
template <typename T, typename N, typename... Args>
T CreateExceptionObject(
    const N& nested_exception, const char* file, int line, const char* function, Args&&... args) {
    if constexpr (std::is_base_of_v<elt::error::CiiException, T>) {
        T throwing_exception = T(std::forward<Args>(args)...);
        throwing_exception.SetFileName(boost::filesystem::path(file).filename().string());
        throwing_exception.SetFunctionName(function);
        throwing_exception.SetLineNumber(line);
        throwing_exception.SetClassName(boost::core::demangle(typeid(T).name()));
        std::vector<std::string> this_stack;
        this_stack.push_back(throwing_exception.getCiiMessage());
        if constexpr (std::is_base_of_v<elt::error::CiiException, N>) {
            std::vector<std::string> nested_stack = nested_exception.getCiiExceptionStack();
            this_stack.insert(this_stack.end(), nested_stack.begin(), nested_stack.end());
        } else if constexpr (std::is_base_of_v<std::exception, N>) {
            this_stack.push_back(nested_exception.what());
        } else {
            this_stack.push_back("Unknown exception.");
        }
        throwing_exception.SetCiiExceptionStack(this_stack);
        return throwing_exception;
    } else {
        return T(std::forward<Args>(args)...);
    }
}
 
}  // namespace
 
// We temporarily redefine the CII_THROW_WITH_NESTED macro to be backwards compatible with
// std::runtime_error and std::logic_error, i.e. to still support these as nested exception.
// TODO: Remove the redefinitions once CII allows std::exceptions for nested exceptions.
 
#ifdef CII_THROW_WITH_NESTED
#undef CII_THROW_WITH_NESTED
 
#define CII_THROW_WITH_NESTED(exceptionType_t, nested_exception, ...)                \
    {                                                                                \
        exceptionType_t throwing_exception = CreateExceptionObject<exceptionType_t>( \
            nested_exception, __FILE__, __LINE__, __FUNCTION__, __VA_ARGS__);        \
        std::throw_with_nested(throwing_exception);                                  \
    }
 
#endif  // CII_THROW_WITH_NESTED
 
namespace rtctk::componentFramework {
namespace detail {
 
template <class T>
struct UnspecifiedNested : virtual T, virtual std::nested_exception {
    template <class E>
    explicit UnspecifiedNested(E&& e) noexcept(std::is_nothrow_constructible_v<T, E&&>)
        : T(std::forward<E>(e)) {
    }
};
 
std::ostream& JoinLines(std::ostream& os,
                        std::string_view lines,
                        std::string_view initial_indent,
                        std::string_view subsequent_indent);
 
}  // namespace detail
 
template <class E>
auto WrapWithNested(E&& exception) noexcept(
    std::is_nothrow_constructible_v<detail::UnspecifiedNested<typename std::decay_t<E>>, E&&>) {
    using Type = typename std::decay_t<E>;
    static_assert(std::is_class_v<Type>, "exception must be a non-union class-type");
 
    return detail::UnspecifiedNested<Type>(std::forward<E>(exception));
}
 
void PrintComposedExceptions(std::ostream& os, std::vector<std::exception_ptr> const& exceptions);
 
void PrintNestedExceptions(std::ostream& os, std::exception const& exception);
 
void PrintNestedExceptions(std::ostream& os, std::exception_ptr ptr);
 
class NestedExceptionPrinter {
public:
    explicit NestedExceptionPrinter(std::exception const& exception) noexcept
        : m_ptr(), m_exception(&exception){};
    explicit NestedExceptionPrinter(std::exception_ptr ptr) noexcept
        : m_ptr(std::move(ptr)), m_exception(nullptr){};
 
    std::string Str() const {
        std::stringstream ss;
        ss << *this;
        return ss.str();
    }
 
    friend std::ostream& operator<<(std::ostream& os, NestedExceptionPrinter const& printer) {
        if (printer.m_ptr) {
            PrintNestedExceptions(os, printer.m_ptr);
        } else if (printer.m_exception) {
            PrintNestedExceptions(os, *printer.m_exception);
        }
        return os;
    }
 
private:
    // A variant or union would occupy same space so this was preferred over
    // including <variant>
    std::exception_ptr m_ptr;
    std::exception const* m_exception;
};
 
class RtctkException : public elt::error::CiiBaseException {
public:
    RtctkException() noexcept;
 
    explicit RtctkException(const std::string& msg);
 
    RtctkException(const RtctkException& other) noexcept;
 
    virtual ~RtctkException() override = default;
};
 
class NotImplementedException : public RtctkException {
public:
    explicit NotImplementedException(const std::string& feature);
};
 
class UnsupportedTypeException : public RtctkException {
public:
    explicit UnsupportedTypeException(const std::string& type);
    explicit UnsupportedTypeException(const std::type_info& type);
    explicit UnsupportedTypeException(const elt::common::CiiBasicDataType type);
};
 
class UnsupportedUriException : public RtctkException {
public:
    explicit UnsupportedUriException(const elt::mal::Uri& uri);
    explicit UnsupportedUriException(const std::string& context, const elt::mal::Uri& uri);
};
 
class BufferTooSmall : public RtctkException {
public:
    explicit BufferTooSmall(const std::size_t actual, const std::size_t expected);
    std::size_t GetActualBufferSize() const {
        return m_actual;
    }
    std::size_t GetExpectedBufferSize() const {
        return m_expected;
    }
 
protected:
    std::size_t m_actual;
    std::size_t m_expected;
};
 
class InvalidArgumentException : public RtctkException {
public:
    explicit InvalidArgumentException(const std::string& message);
};
 
class InitialisationException : public RtctkException {
public:
    explicit InitialisationException(const std::string& message);
};
 
class InvalidStateChange : public RtctkException {
public:
    using RtctkException::RtctkException;
    explicit InvalidStateChange(const std::string& message)
        : RtctkException("Invalid Operation: " + message) {
    }
};
 
class InvalidSetting : public RtctkException {
public:
    using RtctkException::RtctkException;
    explicit InvalidSetting(const std::string& message)
        : RtctkException("Invalid Setting: " + message) {
    }
};
 
class DdtSinkNotFound : public RtctkException {
public:
    using RtctkException::RtctkException;
    explicit DdtSinkNotFound(const std::string& message)
        : RtctkException("DDT Sink not found: " + message) {
    }
};
 
class DdtError : public RtctkException {
public:
    using RtctkException::RtctkException;
    explicit DdtError(const std::string& message)
        : RtctkException("Error in DDT Publisher: " + message) {
    }
};
 
class IpcqError : public RtctkException {
public:
    using RtctkException::RtctkException;
    explicit IpcqError(const std::string& message) : RtctkException("Error in IPCQ: " + message) {
    }
};
 
class AdapterCreationException : public RtctkException {
public:
    explicit AdapterCreationException(const std::string& interface_name);
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_EXCEPTIONS_HPP