150 lines
3.6 KiB
C++
150 lines
3.6 KiB
C++
#pragma once
|
|
|
|
#include <string>
|
|
#include <system_error>
|
|
#include <variant>
|
|
|
|
namespace rublon {
|
|
class NoError {
|
|
public:
|
|
static constexpr int errorClass = 0;
|
|
};
|
|
|
|
class HttpError {
|
|
public:
|
|
enum ErrorClass { Timeout, Error };
|
|
|
|
constexpr HttpError() : errorClass{Timeout}, httpCode(200) {}
|
|
constexpr HttpError(ErrorClass e, long httpCode) : errorClass{e}, httpCode(httpCode) {}
|
|
|
|
ErrorClass errorClass;
|
|
long httpCode;
|
|
};
|
|
|
|
class CoreHandlerError {
|
|
public:
|
|
enum ErrorClass { BadSigature, CoreException, BrokenData };
|
|
|
|
CoreHandlerError(ErrorClass e) : errorClass{e} {}
|
|
CoreHandlerError(ErrorClass e, std::string r) : errorClass{e}, reson{std::move(r)} {}
|
|
|
|
ErrorClass errorClass;
|
|
std::string reson;
|
|
};
|
|
|
|
class MethodError {
|
|
public:
|
|
enum ErrorClass { BadMethod };
|
|
|
|
constexpr MethodError(ErrorClass e) : errorClass{e} {}
|
|
|
|
ErrorClass errorClass;
|
|
};
|
|
|
|
class WerificationError {
|
|
public:
|
|
enum ErrorClass { WrongCode };
|
|
|
|
constexpr WerificationError(ErrorClass e) : errorClass{e} {}
|
|
|
|
ErrorClass errorClass;
|
|
};
|
|
|
|
class Critical {
|
|
public:
|
|
enum ErrorClass { Nok };
|
|
|
|
Critical(ErrorClass e = Nok) : errorClass{e} {}
|
|
|
|
ErrorClass errorClass;
|
|
};
|
|
|
|
class PamBaypass {
|
|
public:
|
|
enum ErrorClass { Nok };
|
|
|
|
constexpr PamBaypass(ErrorClass e = Nok) : errorClass{e} {}
|
|
|
|
ErrorClass errorClass;
|
|
};
|
|
|
|
class PamDeny {
|
|
public:
|
|
enum ErrorClass { Nok };
|
|
|
|
constexpr PamDeny(ErrorClass e = Nok) : errorClass{e} {}
|
|
|
|
ErrorClass errorClass;
|
|
};
|
|
|
|
class Error {
|
|
using Error_t = std::variant< NoError, CoreHandlerError, HttpError, WerificationError, Critical, MethodError, PamBaypass, PamDeny >;
|
|
Error_t _error;
|
|
|
|
public:
|
|
enum Category { k_None, k_CoreHandlerError, k_SockerError, k_WerificationError, k_Critical, k_MethodError, k_PamBaypass, k_PamDeny };
|
|
|
|
Error() = default;
|
|
|
|
Error(CoreHandlerError error) : _error{error} {}
|
|
Error(HttpError error) : _error{error} {}
|
|
Error(MethodError error) : _error{error} {}
|
|
Error(WerificationError error) : _error{error} {}
|
|
Error(Critical error) : _error{error} {}
|
|
Error(PamBaypass error) : _error{error} {}
|
|
Error(PamDeny error) : _error{error} {}
|
|
|
|
Error(const Error &) = default;
|
|
Error(Error &&) = default;
|
|
|
|
Error & operator=(const Error &) = default;
|
|
Error & operator=(Error &&) = default;
|
|
|
|
constexpr bool coreError() const {
|
|
return _error.index() == 1;
|
|
}
|
|
|
|
constexpr bool sockerError() const {
|
|
return _error.index() == 2;
|
|
}
|
|
|
|
constexpr Category category() const noexcept {
|
|
return static_cast< Category >(_error.index());
|
|
}
|
|
|
|
constexpr int errorClass() const noexcept {
|
|
return std::visit([](const auto & e) { return static_cast< int >(e.errorClass); }, _error);
|
|
}
|
|
|
|
template < typename E >
|
|
constexpr bool is() const {
|
|
return category() == Error{E{}}.category();
|
|
}
|
|
|
|
template < typename E >
|
|
constexpr bool isSameCategoryAs(const E & e) const {
|
|
return category() == Error{e}.category();
|
|
}
|
|
|
|
constexpr bool hasClass(int _class) const {
|
|
return errorClass() == _class;
|
|
}
|
|
|
|
template < typename E >
|
|
constexpr bool hasSameErrorClassAs(E e) const {
|
|
assert(isSameCategoryAs(e));
|
|
return errorClass() == Error{e}.errorClass();
|
|
}
|
|
};
|
|
|
|
constexpr bool operator==(const Error & e, const HttpError & socket) {
|
|
return e.sockerError() && e.errorClass() == socket.errorClass;
|
|
}
|
|
|
|
template < typename T >
|
|
constexpr bool operator==(const Error & lhs, const T & rhs) {
|
|
return lhs.isSameCategoryAs(rhs) && lhs.hasSameErrorClassAs(rhs);
|
|
}
|
|
|
|
} // namespace rublon
|