exceptions.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_EXCEPTIONS_HPP
#define RTCTK_COMPONENTFRAMEWORK_EXCEPTIONS_HPP
 
#include <rtctk/config.hpp>
 
#include <ciiBasicDataType.hpp>
#include <ciiException.hpp>
 
#include <concepts>
#include <string_view>
#include <type_traits>
#include <typeinfo>
 
// We temporarily redefine broken CII macros.
// TODO: Remove the redefinitions once they are fixed.
 
#ifdef CII_MAKE_EXCEPTION
#undef CII_MAKE_EXCEPTION
 
#define CII_MAKE_EXCEPTION(exceptionType_t, ...)                   \
    ::error::elt::details::CreateExceptionObject<exceptionType_t>( \
        0, __FILE__, __LINE__, __FUNCTION__, __VA_ARGS__)
 
#endif  // CII_MAKE_EXCEPTION
 
#ifdef CII_MAKE_EXCEPTION_WITH_NESTED
#undef CII_MAKE_EXCEPTION_WITH_NESTED
 
#define CII_MAKE_EXCEPTION_WITH_NESTED(exceptionType_t, nested_exception, ...) \
    ::error::elt::details::CreateExceptionObject<exceptionType_t>(             \
        nested_exception, __FILE__, __LINE__, __FUNCTION__, __VA_ARGS__)
 
#endif  // CII_MAKE_EXCEPTION_WITH_NESTED
 
namespace rtctk::componentFramework {
namespace detail {

template <class T>
struct UnspecifiedNested : virtual T, virtual std::nested_exception {
    template <class E>
        requires std::constructible_from<T, 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, const std::vector<std::exception_ptr>& exceptions);

void PrintNestedExceptions(std::ostream& os, const std::exception& exception);

void PrintNestedExceptions(std::ostream& os, std::exception_ptr ptr);

class NestedExceptionPrinter {
public:
    explicit NestedExceptionPrinter(const std::exception& 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, const NestedExceptionPrinter& 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;
    const std::exception* m_exception;
};

class RtctkException : public elt::error::CiiBaseException {
public:
    RtctkException() noexcept;
 
    explicit RtctkException(const std::string& msg);
 
    RtctkException(const RtctkException& other) noexcept;
 
    ~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 RTCTK_API BufferTooSmall : public RtctkException {
public:
    explicit BufferTooSmall(const std::size_t actual, const std::size_t expected);

    explicit BufferTooSmall(const std::size_t actual,
                            const std::size_t expected,
                            const std::string& reason);
 
    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