Exception.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
namespace Util
{
    enum class ErrorType { Info, Warning, Error, Fatal };
 
    namespace DynExpErrorCodes
    {
        enum DynExpErrorCodes : int {
            NoError = 0,
            GeneralError = -1,
            InvalidArg = -2,
            InvalidState = -3,
            InvalidData = -4,
            InvalidCall = -5,
            Underflow = -6,
            Overflow = -7,
            OutOfRange = -8,
            Empty = -9,
            NotFound = -10,
            TypeError = -11,
            Timeout = -12,
            ThreadDidNotRespond = -13,
            NotAvailable = -14,
            NotImplemented = -15,
            FileIOError = -16,
            LinkedObjectNotLocked = -17,
            InvalidObjectLink = -18,
            ServiceFailed = -19
        };
    }
 
    class Exception : public std::runtime_error
    {
    public:
        Exception(std::string Description = "No exception details available.",
            const ErrorType Type = ErrorType::Error, const int ErrorCode = -1,
            const std::source_location Location = std::source_location::current()) noexcept;
        virtual ~Exception() = default;
 
        constexpr static const char* GetErrorLabel(const ErrorType Type)
        {
            switch (Type)
            {
            case ErrorType::Warning: return "Warning";
            case ErrorType::Error: return "Error";
            case ErrorType::Fatal: return "Fatal Error";
            default: return "Info";
            }
        }
 
        constexpr static const char* GetErrorLabelColor(const ErrorType Type)
        {
            switch (Type)
            {
            case ErrorType::Warning: return "Orange";
            case ErrorType::Error: return "Red";
            case ErrorType::Fatal: return "DarkRed";
            default: return "Blue";
            }
        }
 
        constexpr const char* GetErrorLabel() const { return GetErrorLabel(Type); }
        constexpr const char* GetErrorLabelColor() const { return GetErrorLabelColor(Type); }
 
#ifdef DYNEXP_HAS_STACKTRACE
        auto& GetStackTrace() const { return Trace; }
#endif // DYNEXP_HAS_STACKTRACE
 
        const ErrorType Type;           
        const int ErrorCode;            
        const size_t Line;              
        const std::string Function;     
        const std::string File;         
 
    private:
#ifdef DYNEXP_HAS_STACKTRACE
        const std::stacktrace Trace;
#endif // DYNEXP_HAS_STACKTRACE
    };
 
    class ForwardedException : public Exception
    {
    public:
        ForwardedException() noexcept : Exception("Unknown forwarded exception") {}
        ForwardedException(const std::exception& e) noexcept : Exception(e.what()) {}
        ForwardedException(const Exception& e) noexcept : Exception(e) {}
    };
 
    class InvalidArgException : public Exception
    {
    public:
        InvalidArgException(std::string Description,
            const std::source_location Location = std::source_location::current()) noexcept
            : Exception(std::move(Description), ErrorType::Error, DynExpErrorCodes::InvalidArg, Location)
        {}
    };
 
    class InvalidStateException : public Exception
    {
    public:
        InvalidStateException(std::string Description, const int ErrorCode = DynExpErrorCodes::InvalidState,
            const std::source_location Location = std::source_location::current()) noexcept
            : Exception(std::move(Description), ErrorType::Error, ErrorCode, Location)
        {}
    };
 
    class InvalidDataException : public Exception
    {
    public:
        InvalidDataException(std::string Description,
            const std::source_location Location = std::source_location::current()) noexcept
            : Exception(std::move(Description), ErrorType::Error, DynExpErrorCodes::InvalidData, Location)
        {}
    };
 
    class InvalidCallException : public Exception
    {
    public:
        InvalidCallException(std::string Description,
            const std::source_location Location = std::source_location::current()) noexcept
            : Exception(std::move(Description), ErrorType::Error, DynExpErrorCodes::InvalidCall, Location)
        {}
    };
 
    class UnderflowException : public Exception
    {
    public:
        UnderflowException(std::string Description,
            const std::source_location Location = std::source_location::current()) noexcept
            : Exception(std::move(Description), ErrorType::Error, DynExpErrorCodes::Underflow, Location)
        {}
    };
 
    class OverflowException : public Exception
    {
    public:
        OverflowException(std::string Description,
            const std::source_location Location = std::source_location::current()) noexcept
            : Exception(std::move(Description), ErrorType::Error, DynExpErrorCodes::Overflow, Location)
        {}
    };
 
    class OutOfRangeException : public Exception
    {
    public:
        OutOfRangeException(std::string Description,
            const std::source_location Location = std::source_location::current()) noexcept
            : Exception(std::move(Description), ErrorType::Error, DynExpErrorCodes::OutOfRange, Location)
        {}
    };
 
    class EmptyException : public Exception
    {
    public:
        EmptyException(std::string Description,
            const std::source_location Location = std::source_location::current()) noexcept
            : Exception(std::move(Description), ErrorType::Error, DynExpErrorCodes::Empty, Location)
        {}
    };
 
    class NotFoundException : public Exception
    {
    public:
        NotFoundException(std::string Description,
            const std::source_location Location = std::source_location::current()) noexcept
            : Exception(std::move(Description), ErrorType::Error, DynExpErrorCodes::NotFound, Location)
        {}
    };
 
    class TypeErrorException : public Exception
    {
    public:
        TypeErrorException(const std::source_location Location = std::source_location::current()) noexcept
            : Exception("A base pointer did not belong to the expected derived type.",
                ErrorType::Error, DynExpErrorCodes::TypeError, Location)
        {}
    };
 
    class TimeoutException : public Exception
    {
    public:
        TimeoutException(std::string Description, const ErrorType Type = ErrorType::Warning, const int ErrorCode = DynExpErrorCodes::Timeout,
            const std::source_location Location = std::source_location::current()) noexcept
            : Exception(std::move(Description), Type, ErrorCode, Location)
        {}
    };
 
    class ThreadDidNotRespondException : public TimeoutException
    {
    public:
        ThreadDidNotRespondException(const std::source_location Location = std::source_location::current()) noexcept
            : TimeoutException("Timeout occurred. A thread did not respond. Retry or terminate the program.",
                ErrorType::Error, DynExpErrorCodes::ThreadDidNotRespond, Location)
        {}
    };
 
    class NotAvailableException : public Exception
    {
    public:
        NotAvailableException(std::string Description, const ErrorType Type = ErrorType::Warning,
            const std::source_location Location = std::source_location::current()) noexcept
            : Exception(std::move(Description), Type, DynExpErrorCodes::NotAvailable, Location)
        {}
    };
 
    class NotImplementedException : public Exception
    {
    public:
        NotImplementedException(const std::source_location Location = std::source_location::current()) noexcept
            : Exception("This function has not been implemented for the given item type.",
                ErrorType::Error, DynExpErrorCodes::NotImplemented, Location)
        {}
        NotImplementedException(std::string Description,
            const std::source_location Location = std::source_location::current()) noexcept
            : Exception(std::move(Description), ErrorType::Error, DynExpErrorCodes::NotImplemented, Location)
        {}
    };
 
    class FileIOErrorException : public Exception
    {
    public:
        FileIOErrorException(std::string Filename,
            const std::source_location Location = std::source_location::current()) noexcept
            : Exception("Error reading from or writing to file \"" + Filename + "\".",
                ErrorType::Error, DynExpErrorCodes::FileIOError, Location)
        {}
    };
 
    class LinkedObjectNotLockedException : public InvalidStateException
    {
    public:
        LinkedObjectNotLockedException(const std::source_location Location = std::source_location::current()) noexcept
            : InvalidStateException(
                "A linked object wrapper container is empty. Probably, the respective object link parameter has not been locked calling RunnableInstance::LockObject().",
                DynExpErrorCodes::LinkedObjectNotLocked, Location)
        {}
    };
 
    class InvalidObjectLinkException : public InvalidStateException
    {
    public:
        InvalidObjectLinkException(const std::source_location Location = std::source_location::current()) noexcept
            : InvalidStateException(
                "An object link does not point to a valid destination. Probably, an object referenced by an object link parameter has been removed from the project.",
                DynExpErrorCodes::InvalidObjectLink, Location)
        {}
    };
 
    class ServiceFailedException : public Exception
    {
    public:
        ServiceFailedException(std::string Description, const ErrorType Type = ErrorType::Error,
            const std::source_location Location = std::source_location::current()) noexcept
            : Exception(std::move(Description), Type, DynExpErrorCodes::ServiceFailed, Location)
        {}
    };
 
    std::ostream& operator<<(std::ostream& stream, const Exception& e);
 
    void ForwardException(std::exception_ptr e);
}