error.h

Go to the documentation of this file.

#ifndef ERROR_H
#define ERROR_H
#include <exception>
#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{};

    template<typename ERR, const bool TRIGGERING_CONDITION>
    requires ExtendsOf<error, ERR>
    class staticError
    {
        static_assert(!TRIGGERING_CONDITION);
    };
 
// ----------------- Exception Classes -----------------

class outOfBoundError final : public error {
public:
    [[nodiscard]] auto what() const noexcept -> const char* override
    {
        return "Out of the bound of the object.";
    }
};

class valueError final : public error {
public:
    [[nodiscard]] auto what() const noexcept -> const char* override
    {
        return "Wrong value given.";
    }
};

class nullPointerError final : public error {
public:
    [[nodiscard]] auto what() const noexcept -> const char* override
    {
        return "Attempting to access null pointer.";
    }
};

class unSupportedMethodError final : public error {
public:
    [[nodiscard]] auto what() const noexcept -> const char* override
    {
        return "Unsupported Method for class.";
    }
};

class noElementError final : public error {
public:
    [[nodiscard]] auto what() const noexcept -> const char* override
    {
        return "No such element.";
    }
};

class callbackSignatureError final : public error {
public:
    [[nodiscard]] auto what() const noexcept -> const char* override
    {
        return "Callback signature mismatch.";
    }
};

class callbackReturnTypeError final : public error {
public:
    [[nodiscard]] auto what() const noexcept -> const char* override
    {
        return "Return type of callback mismatch.";
    }
};

class allocateError final : public error
{
    public:
    [[nodiscard]] auto what() const noexcept -> const char* override
    {
        return "Can not allocate memory.";
    }
};
 
class sysError final : public error
{
public:
    [[nodiscard]] auto what() const noexcept -> const char* override
    {
        return "A sys error triggered.";
    }
};
 
} // 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>
{
    static_assert(!TRIGGERING_CONDITION, "A static assert triggered");
};
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::outOfBoundError, TRIGGERING_CONDITION>
{
    static_assert(!TRIGGERING_CONDITION, "Out of the bound of the object");
};
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::valueError, TRIGGERING_CONDITION>
{
    static_assert(!TRIGGERING_CONDITION, "Wrong value given");
};
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::nullPointerError, TRIGGERING_CONDITION>
{
    static_assert(!TRIGGERING_CONDITION, "Attempting to access null pointer");
};
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::unSupportedMethodError, TRIGGERING_CONDITION>
{
    static_assert(!TRIGGERING_CONDITION, "Unsupported Method for class");
};
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::noElementError, TRIGGERING_CONDITION>
{
    static_assert(!TRIGGERING_CONDITION, "No such element");
};
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::callbackSignatureError, TRIGGERING_CONDITION>
{
    static_assert(!TRIGGERING_CONDITION, "Return type of callback mismatch");
};
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::callbackReturnTypeError, TRIGGERING_CONDITION>
{
    static_assert(!TRIGGERING_CONDITION, "Callback signature mismatch");
};
 
template <const bool TRIGGERING_CONDITION>
class original::staticError<original::allocateError, TRIGGERING_CONDITION>
{
    static_assert(!TRIGGERING_CONDITION, "Can not allocate memory");
};
 
#endif // ERROR_H