error.hpp

Go to the documentation of this file.

#ifndef CORAL_ERROR_HPP
#define CORAL_ERROR_HPP

#include <sstream>
#include <stdexcept>
#include <string>
#include <system_error>
#include "coral/config.h"


namespace coral
{

namespace error
{


class ProtocolViolationException : public std::runtime_error
{
public:
    explicit ProtocolViolationException(const std::string& whatArg)
        : std::runtime_error(whatArg) { }

    explicit ProtocolViolationException(const char* whatArg)
        : std::runtime_error(whatArg) { }
};


class ProtocolNotSupported : public std::runtime_error
{
public:
    explicit ProtocolNotSupported(const std::string& whatArg)
        : std::runtime_error(whatArg) { }

    explicit ProtocolNotSupported(const char* whatArg)
        : std::runtime_error(whatArg) { }
};


#define CORAL_INPUT_CHECK(test)                                                  \
    do {                                                                       \
        if (!(test)) {                                                         \
            coral::error::detail::Throw<std::invalid_argument>                   \
                (__FUNCTION__, -1, "Input requirement not satisfied", #test);  \
        }                                                                      \
    } while(false)


class PreconditionViolation : public std::logic_error
{
public:
    explicit PreconditionViolation(const std::string& whatArg)
        : std::logic_error(whatArg) { }
};


#define CORAL_PRECONDITION_CHECK(test)                                        \
    do {                                                                    \
        if (!(test)) {                                                      \
            coral::error::detail::Throw<coral::error::PreconditionViolation>    \
                (__FUNCTION__, -1, "Precondition not satisfied", #test);    \
        }                                                                   \
    } while(false)


namespace detail
{
    // Internal helper function.
    // This function is only designed for use by the macros in this header,
    // and it is subject to change without warning at any time.
    template<class ExceptionT>
    inline void Throw(
        const char* location, int lineNo, const char* msg, const char* detail)
    {
        std::stringstream s;
        s << location;
        if (lineNo >= 0) s << '(' << lineNo << ')';
        s << ": " << msg;
        if (detail) s << ": " << detail;
        throw ExceptionT(s.str());
    }
}


std::string ErrnoMessage(const std::string& msg, int errnoValue) CORAL_NOEXCEPT;


enum class generic_error
{
    aborted = 1,

    canceled,

    operation_failed,

    fatal,
};

const std::error_category& generic_category() CORAL_NOEXCEPT;

enum class sim_error
{
    cannot_perform_timestep = 1,

    data_timeout,
};

const std::error_category& sim_category() CORAL_NOEXCEPT;


// Standard functions to make std::error_code and std::error_condition from
// generic_error and sim_error.
std::error_code make_error_code(generic_error e) CORAL_NOEXCEPT;
std::error_code make_error_code(sim_error e) CORAL_NOEXCEPT;
std::error_condition make_error_condition(generic_error e) CORAL_NOEXCEPT;
std::error_condition make_error_condition(sim_error e) CORAL_NOEXCEPT;


}} // namespace


namespace std
{
    // Register sim_error for implicit conversion to std::error_code
    // TODO: Should this be error_condition?
    template<>
    struct is_error_code_enum<coral::error::sim_error>
        : public true_type
    { };
}
#endif  // header guard