error.h

Go to the documentation of this file.

#ifndef WREPORT_ERROR_H
#define WREPORT_ERROR_H
 
#include <stdexcept>
#include <string>
 
namespace wreport {
 
enum ErrorCode {
    WR_ERR_NONE                 =  0,
    WR_ERR_NOTFOUND             =  1,
    WR_ERR_TYPE                 =  2,
    WR_ERR_ALLOC                =  3,
    WR_ERR_ODBC                 =  4,
    WR_ERR_HANDLES              =  5,
    WR_ERR_TOOLONG              =  6,
    WR_ERR_SYSTEM               =  7,
    WR_ERR_CONSISTENCY          =  8,
    WR_ERR_PARSE                =  9,
    WR_ERR_WRITE                = 10,
    WR_ERR_REGEX                = 11,
    WR_ERR_UNIMPLEMENTED        = 12,
    WR_ERR_DOMAIN               = 13
};
 
#define WREPORT_THROWF_ATTRS(a, b) __attribute__ ((noreturn, format(printf, a, b)))
 
class error : public std::exception
{
public:
    virtual ErrorCode code() const noexcept = 0;
 
    virtual const char* what() const noexcept = 0;
 
    static const char* strerror(ErrorCode code);
};
 
class error_alloc : public error
{
public:
    const char* msg;
 
    error_alloc(const char* msg) : msg(msg) {}
    ~error_alloc() {}
 
    ErrorCode code() const noexcept override { return WR_ERR_ALLOC; }
 
    const char* what() const noexcept override { return msg; }
};
 
namespace errors {
template<ErrorCode ERROR_CODE>
class StringBase : public error
{
public:
    std::string msg;
 
    StringBase(const std::string& msg) noexcept : msg(msg) {}
 
    ErrorCode code() const noexcept override { return ERROR_CODE; }
 
    const char* what() const noexcept override { return msg.c_str(); }
 
};
}
 
class error_notfound : public errors::StringBase<WR_ERR_NOTFOUND>
{
public:
    using StringBase::StringBase;
 
    static void throwf(const char* fmt, ...) WREPORT_THROWF_ATTRS(1, 2);
};
 
class error_type : public errors::StringBase<WR_ERR_TYPE>
{
public:
    using StringBase::StringBase;
 
    static void throwf(const char* fmt, ...) WREPORT_THROWF_ATTRS(1, 2);
};
 
class error_handles : public errors::StringBase<WR_ERR_HANDLES>
{
public:
    using StringBase::StringBase;
 
    static void throwf(const char* fmt, ...) WREPORT_THROWF_ATTRS(1, 2);
};
 
class error_toolong : public errors::StringBase<WR_ERR_TOOLONG>
{
public:
    using StringBase::StringBase;
 
    static void throwf(const char* fmt, ...) WREPORT_THROWF_ATTRS(1, 2);
};
 
class error_system : public errors::StringBase<WR_ERR_SYSTEM>
{
public:
    error_system(const std::string& msg);
 
    error_system(const std::string& msg, int errno_val);
 
    static void throwf(const char* fmt, ...) WREPORT_THROWF_ATTRS(1, 2);
};
 
class error_consistency : public errors::StringBase<WR_ERR_CONSISTENCY>
{
public:
    using StringBase::StringBase;
 
    static void throwf(const char* fmt, ...) WREPORT_THROWF_ATTRS(1, 2);
};
 
class error_parse : public errors::StringBase<WR_ERR_PARSE>
{
public:
    using StringBase::StringBase;
 
    error_parse(const char* file, int line, const std::string& msg);
 
    static void throwf(const char* file, int line, const char* fmt, ...) WREPORT_THROWF_ATTRS(3, 4);
};
 
class error_regexp : public errors::StringBase<WR_ERR_REGEX>
{
public:
    error_regexp(int code, void* re, const std::string& msg);
 
    static void throwf(int code, void* re, const char* fmt, ...) WREPORT_THROWF_ATTRS(3, 4);
};
 
class error_unimplemented : public errors::StringBase<WR_ERR_UNIMPLEMENTED>
{
public:
    using StringBase::StringBase;
 
    static void throwf(const char* fmt, ...) WREPORT_THROWF_ATTRS(1, 2);
};
 
class error_domain : public errors::StringBase<WR_ERR_DOMAIN>
{
public:
    using StringBase::StringBase;
 
    static void throwf(const char* fmt, ...) WREPORT_THROWF_ATTRS(1, 2);
};
 
}
#endif