exceptions.h

Go to the documentation of this file.

 
#pragma once
#include "utils/BaseValue.h"
#include "utils/HexFormatter.h"
#include "utils/Logging.h"
#include "utils/NonCopyable.h"
#include <boost/exception/exception.hpp>
#include <boost/exception/info.hpp>
#include <boost/throw_exception.hpp>
#include <atomic>
#include <exception>
 
#if defined(WIN32) || defined(WIN64)
#define VISIBLE_EXCEPTION_ATTRIBUTE
#else
#define VISIBLE_EXCEPTION_ATTRIBUTE __attribute__ ((visibility ("default")))
#endif
 
namespace catapult {
 
    template<typename TStlException>
    class VISIBLE_EXCEPTION_ATTRIBUTE catapult_error : public TStlException, public boost::exception, public utils::NonCopyable {
    public:
        explicit catapult_error(const char* what) : TStlException(what)
        {}
 
        catapult_error(const catapult_error& rhs)
                : TStlException(rhs.what())
                , boost::exception(rhs)
                , utils::NonCopyable()
        {}
 
        catapult_error(catapult_error&& rhs)
                : TStlException(rhs.what())
                , boost::exception(std::move(rhs))
                , utils::NonCopyable()
        {}
    };
 
    template<typename TStlException>
    class VISIBLE_EXCEPTION_ATTRIBUTE catapult_error<catapult_error<TStlException>> : public catapult_error<TStlException> {
    public:
        explicit catapult_error(const char* what) : catapult_error<TStlException>(what)
        {}
 
        catapult_error(const catapult_error& rhs) : catapult_error<TStlException>(rhs)
        {}
 
        catapult_error(catapult_error&& rhs) : catapult_error<TStlException>(std::move(rhs))
        {}
 
        catapult_error(const catapult_error<TStlException>& rhs) : catapult_error<TStlException>(rhs)
        {}
 
        catapult_error(catapult_error<TStlException>&& rhs) : catapult_error<TStlException>(std::move(rhs))
        {}
    };
 
    using catapult_runtime_error = catapult_error<std::runtime_error>;
    using catapult_invalid_argument = catapult_error<std::invalid_argument>;
    using catapult_out_of_range = catapult_error<std::out_of_range>;
    using catapult_file_io_error = catapult_error<catapult_runtime_error>;
 
    struct ErrorParam1 {};
 
    struct ErrorParam2 {};
 
    namespace exception_detail {
        template<typename T, typename X = std::enable_if_t<!std::is_pointer_v<T>>>
        constexpr T ConvertToValue(const T& value) {
            return value;
        }
 
        template<typename TValue, typename TTag>
        constexpr TValue ConvertToValue(const utils::BaseValue<TValue, TTag>& value) {
            return value.unwrap();
        }
 
        template<typename T>
        constexpr T ConvertToValue(const std::atomic<T>& value) {
            return value;
        }
 
        template<typename TInputIterator>
        std::string ConvertToValue(const utils::ContainerHexFormatter<TInputIterator>& value) {
            // ContainerHexFormatter only holds iterators to data, which may not be valid at catch site
            // since an exception is being thrown, perf doesn't matter, so stringify proactively
            std::ostringstream out;
            out << value;
            return out.str();
        }
 
        template<typename TErrorParam>
        class Make {
        public:
            template<typename T>
            static auto From(const T& value) {
                return boost::error_info<TErrorParam, decltype(ConvertToValue(value))>(ConvertToValue(value));
            }
        };
    }
}
 
#define CATAPULT_THROW_EXCEPTION(EXCEPTION) \
    BOOST_THROW_EXCEPTION(EXCEPTION)
 
#define CATAPULT_THROW_AND_LOG_0(TYPE, MESSAGE) { \
    CATAPULT_LOG(error) << "Throwing exception: " << MESSAGE; \
    CATAPULT_THROW_EXCEPTION(TYPE(MESSAGE)); \
}
 
#define CATAPULT_THROW_AND_LOG_1(TYPE, MESSAGE, PARAM1) { \
    auto detail1 = exception_detail::Make<ErrorParam1>::From(PARAM1); \
    CATAPULT_LOG(error) << "Throwing exception: " << MESSAGE << " (" << detail1.value() << ")"; \
    CATAPULT_THROW_EXCEPTION(TYPE(MESSAGE) << detail1); \
}
 
#define CATAPULT_THROW_AND_LOG_2(TYPE, MESSAGE, PARAM1, PARAM2) { \
    auto detail1 = exception_detail::Make<ErrorParam1>::From(PARAM1); \
    auto detail2 = exception_detail::Make<ErrorParam2>::From(PARAM2); \
    CATAPULT_LOG(error) << "Throwing exception: " << MESSAGE << " (" << detail1.value() << ", " << detail2.value() << ")"; \
    CATAPULT_THROW_EXCEPTION(TYPE(MESSAGE) << detail1 << detail2); \
}
 
#define CATAPULT_THROW_RUNTIME_ERROR(MESSAGE) \
    CATAPULT_THROW_AND_LOG_0(catapult_runtime_error, MESSAGE)
 
#define CATAPULT_THROW_RUNTIME_ERROR_1(MESSAGE, PARAM1) \
    CATAPULT_THROW_AND_LOG_1(catapult_runtime_error, MESSAGE, PARAM1)
 
#define CATAPULT_THROW_RUNTIME_ERROR_2(MESSAGE, PARAM1, PARAM2) \
    CATAPULT_THROW_AND_LOG_2(catapult_runtime_error, MESSAGE, PARAM1, PARAM2)
 
#define CATAPULT_THROW_INVALID_ARGUMENT(MESSAGE) \
    CATAPULT_THROW_AND_LOG_0(catapult_invalid_argument, MESSAGE)
 
#define CATAPULT_THROW_INVALID_ARGUMENT_1(MESSAGE, PARAM1) \
    CATAPULT_THROW_AND_LOG_1(catapult_invalid_argument, MESSAGE, PARAM1)
 
#define CATAPULT_THROW_INVALID_ARGUMENT_2(MESSAGE, PARAM1, PARAM2) \
    CATAPULT_THROW_AND_LOG_2(catapult_invalid_argument, MESSAGE, PARAM1, PARAM2)
 
#define CATAPULT_THROW_OUT_OF_RANGE(MESSAGE) \
    CATAPULT_THROW_AND_LOG_0(catapult_out_of_range, MESSAGE)
 
#define CATAPULT_THROW_FILE_IO_ERROR(MESSAGE) \
    CATAPULT_THROW_AND_LOG_0(catapult_file_io_error, MESSAGE)