Error.hpp

#pragma once
 
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <string_view>
#include <variant>
 
enum class ErrorCode : uint32_t
{
    UnknownError = 0,
 
    GenericError,
 
    RuntimeError,
 
    InvalidProcess,
 
    InvalidThread,
 
    InvalidObject,
 
    InvalidInput,
 
    InvalidParameter,
 
    InvalidState,
 
    PermissionDenied,
 
    InsufficientPrivilegeError,
 
    UnexpectedType,
 
    ArithmeticError,
 
    OverflowError,
 
    UnderflowError,
 
    IllegalValue,
 
    NotImplementedError,
 
    PendingIoError,
 
    ConnectionError,
 
    TerminationError,
 
    AllocationError,
 
    ParsingError,
 
    BufferTooBig,
 
    BufferTooSmall,
 
    NotInitialized,
 
    InitializationFailed,
 
    ServiceError,
 
    FilesystemError,
 
    AlpcError,
 
    ExternalError,
 
    ExternalApiCallFailed,
 
    NoMoreData,
 
    PartialResult,
 
    BadVersion,
 
    BadSignature,
 
    NotFound,
 
    NotConnected,
 
    AlreadyExists,
 
    SizeMismatch,
 
    MalformedFile,
};
 
 
template<typename T>
constexpr auto
Ok(T&& arg)
{
    return std::forward<T>(arg);
}
 
struct Err
{
    ErrorCode Code {ErrorCode::UnknownError};
    uint32_t LastError {0};
 
    bool
    operator==(const Err& rhs) const
    {
        return rhs.Code == this->Code && rhs.LastError == this->LastError;
    }
 
    bool
    operator==(ErrorCode Code) const
    {
        return Code == this->Code;
    }
};
 
 
template<typename T>
using Result = std::variant<T, Err>;
 
 
template<typename T>
constexpr bool
Failed(Result<T> const& Res) noexcept
{
    return std::get_if<Err>(&Res) != nullptr;
}
 
 
template<class T>
constexpr bool
Success(Result<T> const& Result) noexcept
{
    return !Failed(Result);
}
 
 
template<typename T>
T
Value(Result<T>&& SuccessResult)
{
    return std::move(std::get<T>(SuccessResult));
}
 
template<typename T>
T
Value(Result<T>& SuccessResult)
{
    T copy = std::get<T>(SuccessResult);
    return copy;
}
 
template<typename T>
const Err&
Error(Result<T> const& ErrorResult)
{
    return std::get<Err>(ErrorResult);
}
 
 
template<typename T>
T
ValueOr(Result<T>&& Result, T AlternativeValue)
{
    return Success(Result) ? std::move(Value(Result)) : AlternativeValue;
}
 
template<typename T>
T
ValueOr(Result<T>& Result, T AlternativeValue)
{
    return Success(Result) ? Value(Result) : AlternativeValue;
}