error.h

Go to the documentation of this file.

 
#ifndef LLUVIA_CORE_ERROR_H_
#define LLUVIA_CORE_ERROR_H_
 
#include "lluvia/core/enums/enums.h"
 
#include <array>
#include <string>
#include <system_error>
#include <tuple>
 
namespace ll {
 
enum class ErrorCode : ll::enum_t {
    EnumConversionFailed,      
    MemoryMapFailed,           
    ObjectAllocationError,     
    PortBindingError,          
    InvalidShaderFunctionName, 
    InvalidShaderProgram,      
    BufferCopyError,           
    ProgramCompilationError,   
    InvalidLocalShape,         
    InvalidGridShape,          
    BadEnumCasting,            
    PhysicalDevicesNotFound,   
    KeyNotFound,               
    MemoryCreationError,       
    InvalidNodeState,          
    InterpreterError,          
    PushConstantError,         
    IOError,                   
    InvalidArgument,           
    InstanceCreationError,     
    SessionLost,               
    LayerNotFound,             
    ExtensionNotFound,         
    PipelineCreationError,     
    VulkanError,               
    InvalidParameterType       
};
 
namespace impl {
 
    constexpr const std::array<std::tuple<const char*, ll::ErrorCode>, 26> ErrorCodeStrings {{std::make_tuple("EnumConversionFailed", ll::ErrorCode::EnumConversionFailed),
        std::make_tuple("MemoryMapFailed", ll::ErrorCode::MemoryMapFailed),
        std::make_tuple("ObjectAllocationError", ll::ErrorCode::ObjectAllocationError),
        std::make_tuple("PortBindingError", ll::ErrorCode::PortBindingError),
        std::make_tuple("InvalidShaderFunctionName", ll::ErrorCode::InvalidShaderFunctionName),
        std::make_tuple("InvalidShaderProgram", ll::ErrorCode::InvalidShaderProgram),
        std::make_tuple("BufferCopyError", ll::ErrorCode::BufferCopyError),
        std::make_tuple("ProgramCompilationError", ll::ErrorCode::ProgramCompilationError),
        std::make_tuple("InvalidLocalShape", ll::ErrorCode::InvalidLocalShape),
        std::make_tuple("InvalidGridShape", ll::ErrorCode::InvalidGridShape),
        std::make_tuple("BadEnumCasting", ll::ErrorCode::BadEnumCasting),
        std::make_tuple("PhysicalDevicesNotFound", ll::ErrorCode::PhysicalDevicesNotFound),
        std::make_tuple("KeyNotFound", ll::ErrorCode::KeyNotFound),
        std::make_tuple("MemoryCreationError", ll::ErrorCode::MemoryCreationError),
        std::make_tuple("InvalidNodeState", ll::ErrorCode::InvalidNodeState),
        std::make_tuple("InterpreterError", ll::ErrorCode::InterpreterError),
        std::make_tuple("PushConstantError", ll::ErrorCode::PushConstantError),
        std::make_tuple("IOError", ll::ErrorCode::IOError),
        std::make_tuple("InvalidArgument", ll::ErrorCode::InvalidArgument),
        std::make_tuple("InstanceCreationError", ll::ErrorCode::InstanceCreationError),
        std::make_tuple("SessionLost", ll::ErrorCode::SessionLost),
        std::make_tuple("LayerNotFound", ll::ErrorCode::LayerNotFound),
        std::make_tuple("ExtensionNotFound", ll::ErrorCode::ExtensionNotFound),
        std::make_tuple("PipelineCreationError", ll::ErrorCode::PipelineCreationError),
        std::make_tuple("VulkanError", ll::ErrorCode::VulkanError),
        std::make_tuple("InvalidParameterType", ll::ErrorCode::InvalidParameterType)}};
 
} // namespace impl
 
template <typename T = std::string>
inline T errorCodeToString(ll::ErrorCode&& value) noexcept
{
    return impl::enumToString<ll::ErrorCode, ll::impl::ErrorCodeStrings.size(), ll::impl::ErrorCodeStrings>(std::forward<ll::ErrorCode>(value));
}
 
class ErrorCategory : public std::error_category {
 
public:
    static ErrorCategory& getInstance() noexcept;
 
    virtual const char* name() const noexcept override { return "ll::ErrorCode"; }
 
    virtual std::string message(int ev) const override { return errorCodeToString(static_cast<ll::ErrorCode>(ev)); }
};
 
inline std::error_code createErrorCode(ll::ErrorCode errorCode)
{
    return std::error_code {static_cast<int>(errorCode), ErrorCategory::getInstance()};
}
 
template <typename T>
void throwSystemErrorIf(bool condition, ll::ErrorCode errorCode, T&& msg)
{
 
    static_assert(std::is_convertible<T, std::string>(), "T must be a string-like type");
 
    if (condition) {
        throw std::system_error(createErrorCode(errorCode), msg);
    }
}
 
template <typename T>
void throwSystemError(ll::ErrorCode errorCode, T&& msg)
{
 
    static_assert(std::is_convertible<T, std::string>(), "T must be a string-like type");
    throw std::system_error(createErrorCode(errorCode), msg);
}
 
} // namespace ll
 
#endif // LLUVIA_CORE_ERROR_H_