CppRuntimeException.h

Go to the documentation of this file.

#ifndef ZSERIO_CPP_RUNTIME_EXCEPTION_H_INC
#define ZSERIO_CPP_RUNTIME_EXCEPTION_H_INC
 
#include <array>
#include <exception>
#include <string>
#include <type_traits>
#include <vector>
 
#include "zserio/Span.h"
#include "zserio/StringConvertUtil.h"
#include "zserio/Traits.h"
#include "zserio/Types.h"
 
namespace zserio
{
 
class CppRuntimeException : public std::exception
{
public:
    explicit CppRuntimeException(const char* message = "");
 
    ~CppRuntimeException() override = default;
 
    CppRuntimeException(const CppRuntimeException& other) = default;
    CppRuntimeException& operator=(const CppRuntimeException& other) = default;
 
    CppRuntimeException(CppRuntimeException&& other) = default;
    CppRuntimeException& operator=(CppRuntimeException&& other) = default;
    const char* what() const noexcept override;
 
    void append(const char* message);
 
    void append(const char* message, size_t messageLen);
 
private:
    void appendImpl(Span<const char> message);
 
    std::array<char, 512> m_buffer; // note fixed sized array is deeply copied on copy operations and it's OK
    size_t m_len = 0;
};
 
CppRuntimeException& operator<<(CppRuntimeException& exception, const char* message);
 
CppRuntimeException& operator<<(CppRuntimeException& exception, bool value);
 
CppRuntimeException& operator<<(CppRuntimeException& exception, float value);
 
CppRuntimeException& operator<<(CppRuntimeException& exception, double value);
 
template <typename T, typename std::enable_if<std::is_integral<T>::value, int>::type = 0>
CppRuntimeException& operator<<(CppRuntimeException& exception, T value)
{
    std::array<char, 24> buffer = {};
    const char* stringValue = convertIntToString(buffer, value);
    return exception << stringValue;
}
 
template <typename T, typename std::enable_if<is_bitmask<T>::value, int>::type = 0>
CppRuntimeException& operator<<(CppRuntimeException& exception, T value)
{
    exception << value.getValue();
    return exception;
}
 
template <typename ALLOC>
CppRuntimeException& operator<<(
        CppRuntimeException& exception, const std::basic_string<char, std::char_traits<char>, ALLOC>& value)
{
    exception.append(value.c_str(), value.size());
    return exception;
}
 
template <typename T, typename ALLOC>
CppRuntimeException& operator<<(CppRuntimeException& exception, const std::vector<T, ALLOC>& value)
{
    return exception << "vector([...], " << value.size() << ")";
}
 
namespace detail
{
 
// inspired by C++ ostreams - see https://cplusplus.github.io/LWG/issue1203
// note that e.g. in gcc implementation of ostreams there are two constraints, but the second one:
//      typename = decltype(std::declval<EXCEPTION&>() << std::declval<const VALUE&>())
// is probably unnecessary and since it caused a compilation error in MSVC 2017 Conformance Mode,
// we intentionally skipped it (even though it was probably a compiler bug)
template <typename EXCEPTION, typename VALUE,
        typename = typename std::enable_if<std::is_base_of<CppRuntimeException, EXCEPTION>::value, int>::type>
using CppRuntimeExceptionRValueInsertion = EXCEPTION&&;
 
} // namespace detail
 
template <typename CPP_RUNTIME_EXCEPTION, typename T>
detail::CppRuntimeExceptionRValueInsertion<CPP_RUNTIME_EXCEPTION, T> operator<<(
        CPP_RUNTIME_EXCEPTION&& exception, const T& value)
{
    exception << value;
    return std::forward<CPP_RUNTIME_EXCEPTION>(exception);
}
 
} // namespace zserio
 
#endif // ifndef ZSERIO_CPP_RUNTIME_EXCEPTION_H_INC