ThreadingError.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
 
#include "../Common/Result.h"
 
namespace SC
{
 
enum class ThreadingError : uint32_t
{
    InvalidThreadFunction = 1,
    ThreadAlreadyStarted,
    ThreadNotStarted,
    ThreadCreationFailed,
    ThreadJoinFailed,
    ThreadDetachFailed,
    ThreadPoolAlreadyCreated,
    InvalidWorkerThreadCount,
    ThreadPoolNotCreated,
    TaskAlreadyQueued,
    TaskInUseByAnotherThreadPool,
    ThreadPoolThreadCreationFailed,
};
 
enum class ThreadingErrorDetail : uint32_t
{
    None = 0,
    PosixPthreadCreate,
    PosixPthreadJoin,
    PosixPthreadDetach,
    WindowsCreateThread,
    WindowsWaitForSingleObject,
    WindowsCloseHandle,
};
 
static constexpr ResultCategory ThreadingResultCategory = ResultCategory(1);
 
struct [[nodiscard]] ResultThreading
{
    Result               result;
    uint32_t             nativeError = 0;
    ThreadingErrorDetail detail      = ThreadingErrorDetail::None;
 
    explicit constexpr ResultThreading(bool valid = true) : result(valid) {}
    constexpr ResultThreading(ThreadingError error, ThreadingErrorDetail detail = ThreadingErrorDetail::None,
                              uint32_t nativeError = 0)
        : result(Result::Error(ThreadingResultCategory, error)), nativeError(nativeError), detail(detail)
    {}
    constexpr ResultThreading(Result result) : result(result) {}
 
    template <typename ResultLike>
    constexpr ResultThreading(const ResultLike& other) : result(other.toResult())
    {}
 
    explicit constexpr operator bool() const { return static_cast<bool>(result); }
 
    constexpr operator Result() const { return result; }
 
    constexpr Result toResult() const { return result; }
    constexpr bool   isError(ThreadingError error) const { return result.isError(ThreadingResultCategory, error); }
};
 
} // namespace SC