error.h

Go to the documentation of this file.

#ifndef ERROR_H
#define ERROR_H
#include <exception>
#include "printable.h"
#include "types.h"
 
namespace original {
 
    class callBackChecker {
    public:
        template<typename Callback, typename Ret_TYPE, typename ...Args_TYPE>
        static void check();
    };
 
    class error
            : public std::exception,
              public printable {
    #define ORIGINAL_ERROR_MSG "An error thrown"
    protected:
        mutable std::string msg_;
 
        virtual std::string defaultMsg() const {
            return ORIGINAL_ERROR_MSG;
        }
    public:
        explicit error(std::string msg) : msg_(std::move(msg)) {}
 
        std::string className() const override {
            return "error";
        }
 
        std::string message() const noexcept {
            std::stringstream ss;
            ss << "Original::" << this->className() << ": ";
            if (!this->msg_.empty()){
                ss << this->msg_ << ".";
            } else {
                ss << this->defaultMsg() << ".";
            }
            return ss.str();
        }
 
        const char* what() const noexcept override {
            this->msg_ = this->message();
            return this->msg_.c_str();
        }
    };
 
    template<typename ERR, const bool TRIGGERING_CONDITION>
    requires ExtendsOf<error, ERR>
    class staticError
    {
    public:
        static void asserts(){
            static_assert(!TRIGGERING_CONDITION);
        }
    };
 
// ----------------- Exception Classes -----------------
 
class outOfBoundError final : public error {
public:
    #define ORIGINAL_OUT_OF_BOUND_ERROR_MSG "Wrong value given"
 
    explicit outOfBoundError(std::string msg = "")
        : error(std::move(msg)) {}
 
    std::string className() const override{
        return "outOfBoundError";
    }
 
    std::string defaultMsg() const override {
        return ORIGINAL_OUT_OF_BOUND_ERROR_MSG;
    }
};
 
class valueError final : public error {
public:
    #define ORIGINAL_VALUE_ERROR_ERROR_MSG "Wrong value given"
 
    explicit valueError(std::string msg = "")
    : error(std::move(msg)) {}
 
    std::string className() const override{
        return "valueError";
    }
 
    std::string defaultMsg() const override {
        return ORIGINAL_VALUE_ERROR_ERROR_MSG;
    }
};
 
class nullPointerError final : public error {
public:
    #define ORIGINAL_NULL_POINTER_ERROR_MSG "Attempting to access null pointer"
 
    explicit nullPointerError(std::string msg = "")
    : error(std::move(msg)) {}
 
    std::string className() const override{
        return "nullPointerError";
    }
 
    std::string defaultMsg() const override {
        return ORIGINAL_NULL_POINTER_ERROR_MSG;
    }
};
 
class unSupportedMethodError final : public error {
public:
    #define ORIGINAL_UNSUPPORTED_METHOD_ERROR_MSG "Unsupported Method for the call"
 
    explicit unSupportedMethodError(std::string msg = "")
    : error(std::move(msg)) {}
 
    std::string className() const override{
        return "unSupportedMethodError";
    }
 
    std::string defaultMsg() const override {
        return ORIGINAL_UNSUPPORTED_METHOD_ERROR_MSG;
    }
};
 
class noElementError final : public error {
public:
    #define ORIGINAL_NO_ELEMENT_ERROR_MSG "No such element"
 
    explicit noElementError(std::string msg = "")
    : error(std::move(msg)) {}
 
    std::string className() const override{
        return "noElementError";
    }
 
    std::string defaultMsg() const override {
        return ORIGINAL_NO_ELEMENT_ERROR_MSG;
    }
};
 
class callbackSignatureError final : public error {
public:
    #define ORIGINAL_CALLBACK_SIGNATURE_ERROR_MSG "Callback signature mismatch"
 
    explicit callbackSignatureError(std::string msg = "")
    : error(std::move(msg)) {}
 
    std::string className() const override{
        return "callbackSignatureError";
    }
 
    std::string defaultMsg() const override {
        return ORIGINAL_CALLBACK_SIGNATURE_ERROR_MSG;
    }
};
 
class callbackReturnTypeError final : public error {
public:
    #define ORIGINAL_CALLBACK_RETURN_TYPE_ERROR_MSG "Return type of callback mismatch"
 
    explicit callbackReturnTypeError(std::string msg = "")
    : error(std::move(msg)) {}
 
    std::string className() const override{
        return "callbackReturnTypeError";
    }
 
    std::string defaultMsg() const override {
        return ORIGINAL_CALLBACK_RETURN_TYPE_ERROR_MSG;
    }
};
 
class allocateError final : public error
{
public:
    #define ORIGINAL_ALLOCATE_ERROR_MSG "Can not allocate memory"
 
    explicit allocateError(std::string msg = "")
    : error(std::move(msg)) {}
 
    std::string className() const override{
        return "allocateError";
    }
 
    std::string defaultMsg() const override {
        return ORIGINAL_ALLOCATE_ERROR_MSG;
    }
};
 
class sysError final : public error
{
public:
    #define ORIGINAL_SYS_ERROR_MSG "A system error triggered"
 
    explicit sysError(std::string msg = "")
    : error(std::move(msg)) {}
 
    std::string className() const override{
        return "sysError";
    }
 
    std::string defaultMsg() const override {
        return ORIGINAL_SYS_ERROR_MSG;
    }
};
 
} // namespace original
 
// ----------------- Definitions of error.h -----------------
 
template<typename Callback, typename Ret_TYPE, typename... Args_TYPE>
void original::callBackChecker::check() {
    if constexpr (constexpr bool is_valid = std::is_invocable_v<Callback, Args_TYPE...>;
        !is_valid){
        throw callbackSignatureError();
    } else{
        using result_type = std::invoke_result_t<Callback, Args_TYPE...>;
        if constexpr (constexpr bool is_valid_return_type = std::is_same_v<result_type, Ret_TYPE>;
            !is_valid_return_type)
            throw callbackReturnTypeError();
    }
}
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::error, TRIGGERING_CONDITION>
{
public:
    static void asserts(){
        static_assert(!TRIGGERING_CONDITION, ORIGINAL_ERROR_MSG);
    }
};
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::outOfBoundError, TRIGGERING_CONDITION>
{
public:
    static void asserts(){
        static_assert(!TRIGGERING_CONDITION, ORIGINAL_OUT_OF_BOUND_ERROR_MSG);
    }
};
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::valueError, TRIGGERING_CONDITION>
{
public:
    static void asserts(){
        static_assert(!TRIGGERING_CONDITION, ORIGINAL_VALUE_ERROR_ERROR_MSG);
    }
};
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::nullPointerError, TRIGGERING_CONDITION>
{
public:
    static void asserts(){
        static_assert(!TRIGGERING_CONDITION, ORIGINAL_NULL_POINTER_ERROR_MSG);
    }
};
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::unSupportedMethodError, TRIGGERING_CONDITION>
{
public:
    static void asserts(){
        static_assert(!TRIGGERING_CONDITION, ORIGINAL_UNSUPPORTED_METHOD_ERROR_MSG);
    }
};
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::noElementError, TRIGGERING_CONDITION>
{
public:
    static void asserts(){
        static_assert(!TRIGGERING_CONDITION, ORIGINAL_NO_ELEMENT_ERROR_MSG);
    }
};
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::callbackSignatureError, TRIGGERING_CONDITION>
{
public:
    static void asserts(){
        static_assert(!TRIGGERING_CONDITION, ORIGINAL_CALLBACK_SIGNATURE_ERROR_MSG);
    }
};
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::callbackReturnTypeError, TRIGGERING_CONDITION>
{
public:
    static void asserts(){
        static_assert(!TRIGGERING_CONDITION, ORIGINAL_CALLBACK_RETURN_TYPE_ERROR_MSG);
    }
};
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::allocateError, TRIGGERING_CONDITION>
{
public:
    static void asserts(){
        static_assert(!TRIGGERING_CONDITION, ORIGINAL_ALLOCATE_ERROR_MSG);
    }
};
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::sysError, TRIGGERING_CONDITION>
{
public:
    static void asserts(){
        static_assert(!TRIGGERING_CONDITION, ORIGINAL_SYS_ERROR_MSG);
    }
};
 
#endif // ERROR_H