SocketError.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
 
#include "../Common/Result.h"
 
namespace SC
{
 
enum class SocketError : uint32_t
{
    NetworkingNotInitialized = 1,
    UnsupportedTextEncoding,
    InputCapacityExceeded,
    InvalidIPAddress,
    InvalidAddress,
    AddressTypeMismatch,
    AddressFamilyMismatch,
    OperationUnsupported,
    InvalidSocket,
    DestinationSocketInUse,
    InvalidShutdownType,
    SocketCreationFailed,
    SocketCloseFailed,
    DescriptorQueryFailed,
    DescriptorConfigurationFailed,
    SocketOptionFailed,
    ShutdownFailed,
    BindFailed,
    AddressInUse,
    ListenFailed,
    AcceptFailed,
    ConnectFailed,
    SendFailed,
    ReceiveFailed,
    IncompleteSend,
    DatagramTruncated,
    WouldBlock,
    TimedOut,
    DNSResolutionFailed,
    OutputCapacityExceeded,
};
 
enum class SocketErrorDetail : uint16_t
{
    None = 0,
    ParseIPv4Address,
    ParseIPv6Address,
    BuildUnixPathAddress,
    BuildUnixAbstractAddress,
    ExtractIPAddress,
    ExtractUnixAddress,
    CopyHostName,
    ResolveHostName,
    CopyResolvedAddress,
    GetSocketAddress,
    PosixCloseDescriptor,
    WindowsCloseSocket,
    PosixGetDescriptorFlags,
    PosixSetDescriptorFlags,
    WindowsGetHandleInformation,
    WindowsSetHandleInformation,
    WindowsSetBlocking,
    CreateSocket,
    SetTcpNoDelay,
    SetBroadcast,
    JoinIPv4Multicast,
    JoinIPv6Multicast,
    LeaveIPv4Multicast,
    LeaveIPv6Multicast,
    SetIPv4MulticastLoopback,
    SetIPv6MulticastLoopback,
    SetIPv4MulticastHops,
    SetIPv6MulticastHops,
    SetIPv4MulticastInterface,
    SetIPv6MulticastInterface,
    ShutdownSocket,
    SendDatagram,
    ReceiveDatagram,
    BindSocket,
    ListenSocket,
    AcceptConnection,
    ConnectSocket,
    SendStream,
    ReceiveStream,
    WaitForRead,
};
 
enum class SocketErrorContextKind : uint16_t
{
    None = 0,
    NativeError,
    ResolverError,
    RequiredBytes,
    ActualBytes,
};
 
union SocketErrorContext
{
    struct ResolverError
    {
    };
    struct RequiredBytes
    {
    };
    struct ActualBytes
    {
    };
 
    uint32_t nativeError;
    int32_t  resolverError;
    uint32_t requiredBytes;
    uint32_t actualBytes;
 
    constexpr SocketErrorContext(uint32_t value = 0) : nativeError(value) {}
    constexpr SocketErrorContext(ResolverError, int32_t value) : resolverError(value) {}
    constexpr SocketErrorContext(RequiredBytes, uint32_t value) : requiredBytes(value) {}
    constexpr SocketErrorContext(ActualBytes, uint32_t value) : actualBytes(value) {}
};
 
static constexpr ResultCategory SocketResultCategory = ResultCategory(8);
 
struct [[nodiscard]] ResultSocket
{
    Result                 result;
    SocketErrorDetail      detail      = SocketErrorDetail::None;
    SocketErrorContextKind contextKind = SocketErrorContextKind::None;
    SocketErrorContext     context     = {};
 
    constexpr ResultSocket() : result(true) {}
    explicit constexpr ResultSocket(bool valid) : result(valid) {}
    constexpr ResultSocket(SocketError error, SocketErrorDetail detail = SocketErrorDetail::None)
        : result(Result::Error(SocketResultCategory, error)), detail(detail)
    {}
    constexpr ResultSocket(SocketError error, SocketErrorDetail detail, SocketErrorContextKind contextKind,
                           SocketErrorContext context)
        : result(Result::Error(SocketResultCategory, error)), detail(detail), contextKind(contextKind), context(context)
    {}
    constexpr ResultSocket(Result result) : result(result) {}
 
    template <typename ResultLike>
    constexpr ResultSocket(const ResultLike& other) : result(other.toResult())
    {}
 
    static constexpr ResultSocket withNativeError(SocketError error, SocketErrorDetail detail, uint32_t nativeError)
    {
        return {error, detail, SocketErrorContextKind::NativeError, SocketErrorContext(nativeError)};
    }
 
    static constexpr ResultSocket withResolverError(SocketError error, SocketErrorDetail detail, int32_t resolverError)
    {
        return {error, detail, SocketErrorContextKind::ResolverError,
                SocketErrorContext(SocketErrorContext::ResolverError{}, resolverError)};
    }
 
    static constexpr ResultSocket withRequiredBytes(SocketError error, SocketErrorDetail detail, uint32_t requiredBytes)
    {
        return {error, detail, SocketErrorContextKind::RequiredBytes,
                SocketErrorContext(SocketErrorContext::RequiredBytes{}, requiredBytes)};
    }
 
    static constexpr ResultSocket withActualBytes(SocketError error, SocketErrorDetail detail, uint32_t actualBytes)
    {
        return {error, detail, SocketErrorContextKind::ActualBytes,
                SocketErrorContext(SocketErrorContext::ActualBytes{}, actualBytes)};
    }
 
    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(SocketError error) const { return result.isError(SocketResultCategory, error); }
};
 
} // namespace SC