From 12495c01d50343a8c405a93a40ed1500d0d0dc7a Mon Sep 17 00:00:00 2001 From: Val Date: Sat, 28 Feb 2026 20:10:28 +0100 Subject: [PATCH] refactor error variants --- lightbug_http/address.mojo | 162 +--- lightbug_http/c/network.mojo | 80 +- lightbug_http/c/socket.mojo | 280 +++--- lightbug_http/c/socket_error.mojo | 1448 ++++------------------------- lightbug_http/socket.mojo | 2 +- 5 files changed, 362 insertions(+), 1610 deletions(-) diff --git a/lightbug_http/address.mojo b/lightbug_http/address.mojo index 93c8cc2d..4b0d562a 100644 --- a/lightbug_http/address.mojo +++ b/lightbug_http/address.mojo @@ -372,10 +372,10 @@ fn get_ip_address( try: result = getaddrinfo(host, service, hints) except getaddrinfo_err: - raise getaddrinfo_err + raise GetIPAddressError(getaddrinfo_err) if not result.unsafe_ptr()[].ai_addr: - raise GetaddrinfoNullAddrError() + raise GetIPAddressError(GetaddrinfoNullAddrError()) # extend result's lifetime to avoid invalid access of pointer, it'd get freed early return ( @@ -396,10 +396,10 @@ fn get_ip_address( try: result = getaddrinfo(host, service, hints) except getaddrinfo_err: - raise getaddrinfo_err + raise GetIPAddressError(getaddrinfo_err) if not result.unsafe_ptr()[].ai_addr: - raise GetaddrinfoNullAddrError() + raise GetIPAddressError(GetaddrinfoNullAddrError()) return ( result.unsafe_ptr()[] @@ -561,125 +561,21 @@ struct GetaddrinfoError(CustomError, TrivialRegisterPassable): -@fieldwise_init -struct GetIPAddressError(Movable, Stringable, Writable): - """Typed error variant for get_ip_address() function.""" - - comptime type = Variant[GetaddrinfoError, GetaddrinfoNullAddrError] - var value: Self.type - - @implicit - fn __init__(out self, value: GetaddrinfoError): - self.value = value - - @implicit - fn __init__(out self, value: GetaddrinfoNullAddrError): - self.value = value - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[GetaddrinfoError](): - writer.write(self.value[GetaddrinfoError]) - elif self.value.isa[GetaddrinfoNullAddrError](): - writer.write(self.value[GetaddrinfoNullAddrError]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) - - -@fieldwise_init -struct ParseError(Movable, Stringable, Writable): - """Typed error variant for address parsing functions.""" - - comptime type = Variant[ - ParseEmptyAddressError, - ParseMissingClosingBracketError, - ParseMissingPortError, - ParseUnexpectedBracketError, - ParseEmptyPortError, - ParseInvalidPortNumberError, - ParsePortOutOfRangeError, - ParseMissingSeparatorError, - ParseTooManyColonsError, - ParseIPProtocolPortError, - ] - var value: Self.type - - @implicit - fn __init__(out self, value: ParseEmptyAddressError): - self.value = value - - @implicit - fn __init__(out self, value: ParseMissingClosingBracketError): - self.value = value - - @implicit - fn __init__(out self, value: ParseMissingPortError): - self.value = value - - @implicit - fn __init__(out self, value: ParseUnexpectedBracketError): - self.value = value - - @implicit - fn __init__(out self, value: ParseEmptyPortError): - self.value = value - - @implicit - fn __init__(out self, value: ParseInvalidPortNumberError): - self.value = value +comptime GetIPAddressError = Variant[GetaddrinfoError, GetaddrinfoNullAddrError] - @implicit - fn __init__(out self, value: ParsePortOutOfRangeError): - self.value = value - @implicit - fn __init__(out self, value: ParseMissingSeparatorError): - self.value = value - - @implicit - fn __init__(out self, value: ParseTooManyColonsError): - self.value = value - - @implicit - fn __init__(out self, value: ParseIPProtocolPortError): - self.value = value - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[ParseEmptyAddressError](): - writer.write(self.value[ParseEmptyAddressError]) - elif self.value.isa[ParseMissingClosingBracketError](): - writer.write(self.value[ParseMissingClosingBracketError]) - elif self.value.isa[ParseMissingPortError](): - writer.write(self.value[ParseMissingPortError]) - elif self.value.isa[ParseUnexpectedBracketError](): - writer.write(self.value[ParseUnexpectedBracketError]) - elif self.value.isa[ParseEmptyPortError](): - writer.write(self.value[ParseEmptyPortError]) - elif self.value.isa[ParseInvalidPortNumberError](): - writer.write(self.value[ParseInvalidPortNumberError]) - elif self.value.isa[ParsePortOutOfRangeError](): - writer.write(self.value[ParsePortOutOfRangeError]) - elif self.value.isa[ParseMissingSeparatorError](): - writer.write(self.value[ParseMissingSeparatorError]) - elif self.value.isa[ParseTooManyColonsError](): - writer.write(self.value[ParseTooManyColonsError]) - elif self.value.isa[ParseIPProtocolPortError](): - writer.write(self.value[ParseIPProtocolPortError]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) +comptime ParseError = Variant[ + ParseEmptyAddressError, + ParseMissingClosingBracketError, + ParseMissingPortError, + ParseUnexpectedBracketError, + ParseEmptyPortError, + ParseInvalidPortNumberError, + ParsePortOutOfRangeError, + ParseMissingSeparatorError, + ParseTooManyColonsError, + ParseIPProtocolPortError, +] fn parse_ipv6_bracketed_address[ @@ -695,14 +591,14 @@ fn parse_ipv6_bracketed_address[ var end_bracket_index = address.find("]") if end_bracket_index == -1: - raise ParseMissingClosingBracketError() + raise ParseError(ParseMissingClosingBracketError()) if end_bracket_index + 1 == len(address): - raise ParseMissingPortError() + raise ParseError(ParseMissingPortError()) var colon_index = end_bracket_index + 1 if address[colon_index : colon_index + 1] != ":": - raise ParseMissingPortError() + raise ParseError(ParseMissingPortError()) return address[1:end_bracket_index], UInt16(end_bracket_index + 1) @@ -719,24 +615,24 @@ fn validate_no_brackets[ segment = address[Int(start_idx) : Int(end_idx.value())] if segment.find("[") != -1: - raise ParseUnexpectedBracketError() + raise ParseError(ParseUnexpectedBracketError()) if segment.find("]") != -1: - raise ParseUnexpectedBracketError() + raise ParseError(ParseUnexpectedBracketError()) fn parse_port[origin: ImmutOrigin](port_str: StringSlice[origin]) raises ParseError -> UInt16: """Parse and validate port number.""" if port_str == AddressConstants.EMPTY: - raise ParseEmptyPortError() + raise ParseError(ParseEmptyPortError()) var port: Int try: port = Int(String(port_str)) except conversion_err: - raise ParseInvalidPortNumberError() + raise ParseError(ParseInvalidPortNumberError()) if port < MIN_PORT or port > MAX_PORT: - raise ParsePortOutOfRangeError() + raise ParseError(ParsePortOutOfRangeError()) return UInt16(port) @@ -765,7 +661,7 @@ fn parse_address[ Tuple containing the host and port. """ if address == AddressConstants.EMPTY: - raise ParseEmptyAddressError() + raise ParseError(ParseEmptyAddressError()) if address == AddressConstants.LOCALHOST: @@ -781,13 +677,13 @@ fn parse_address[ return HostPort(String(address), DEFAULT_IP_PORT) if address.find(":") != -1: - raise ParseIPProtocolPortError() + raise ParseError(ParseIPProtocolPortError()) return HostPort(String(address), DEFAULT_IP_PORT) var colon_index = address.rfind(":") if colon_index == -1: - raise ParseMissingSeparatorError() + raise ParseError(ParseMissingSeparatorError()) var host: StringSlice[origin] var port: UInt16 @@ -802,7 +698,7 @@ fn parse_address[ else: host = address[:colon_index] if host.find(":") != -1: - raise ParseTooManyColonsError() + raise ParseError(ParseTooManyColonsError()) port = parse_port(address[colon_index + 1 :]) if host == AddressConstants.LOCALHOST: diff --git a/lightbug_http/c/network.mojo b/lightbug_http/c/network.mojo index e5f3de10..4c9889b0 100644 --- a/lightbug_http/c/network.mojo +++ b/lightbug_http/c/network.mojo @@ -41,72 +41,10 @@ struct InetPtonInvalidAddressError(CustomError, TrivialRegisterPassable): return Self.message -@fieldwise_init -struct InetNtopError(Movable, Stringable, Writable): - """Typed error variant for inet_ntop() function.""" - - comptime type = Variant[InetNtopEAFNOSUPPORTError, InetNtopENOSPCError, Error] - var value: Self.type - - @implicit - fn __init__(out self, value: InetNtopEAFNOSUPPORTError): - self.value = value - - @implicit - fn __init__(out self, value: InetNtopENOSPCError): - self.value = value - - @implicit - fn __init__(out self, var value: Error): - self.value = value^ - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[InetNtopEAFNOSUPPORTError](): - writer.write(self.value[InetNtopEAFNOSUPPORTError]) - elif self.value.isa[InetNtopENOSPCError](): - writer.write(self.value[InetNtopENOSPCError]) - elif self.value.isa[Error](): - writer.write(self.value[Error]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) +comptime InetNtopError = Variant[InetNtopEAFNOSUPPORTError, InetNtopENOSPCError, Error] -@fieldwise_init -struct InetPtonError(Movable, Stringable, Writable): - """Typed error variant for inet_pton() function.""" - - comptime type = Variant[InetPtonInvalidAddressError, Error] - var value: Self.type - - @implicit - fn __init__(out self, value: InetPtonInvalidAddressError): - self.value = value - - @implicit - fn __init__(out self, var value: Error): - self.value = value^ - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[InetPtonInvalidAddressError](): - writer.write(self.value[InetPtonInvalidAddressError]) - elif self.value.isa[Error](): - writer.write(self.value[Error]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) +comptime InetPtonError = Variant[InetPtonInvalidAddressError, Error] fn htonl(hostlong: c_uint) -> c_uint: @@ -394,14 +332,14 @@ fn inet_ntop[ if not result: var errno = get_errno() if errno == errno.EAFNOSUPPORT: - raise InetNtopEAFNOSUPPORTError() + raise InetNtopError(InetNtopEAFNOSUPPORTError()) elif errno == errno.ENOSPC: - raise InetNtopENOSPCError() + raise InetNtopError(InetNtopENOSPCError()) else: - raise Error( + raise InetNtopError(Error( "inet_ntop Error: An error occurred while converting the address. Error code: ", errno, - ) + )) return String(unsafe_from_utf8_ptr=dst.unsafe_ptr()) @@ -472,12 +410,12 @@ fn inet_pton[address_family: AddressFamily](var src: String) raises InetPtonErro var result = _inet_pton(address_family.value, src.as_c_string_slice().unsafe_ptr(), ip_buffer) if result == 0: - raise InetPtonInvalidAddressError() + raise InetPtonError(InetPtonInvalidAddressError()) elif result == -1: var errno = get_errno() - raise Error( + raise InetPtonError(Error( "inet_pton Error: An error occurred while converting the address. Error code: ", errno, - ) + )) return ip_buffer.bitcast[c_uint]().take_pointee() diff --git a/lightbug_http/c/socket.mojo b/lightbug_http/c/socket.mojo index 53c98d13..cdc0d935 100644 --- a/lightbug_http/c/socket.mojo +++ b/lightbug_http/c/socket.mojo @@ -235,19 +235,19 @@ fn socket(domain: c_int, type: c_int, protocol: c_int) raises SocketError -> c_i if fd == -1: var errno = get_errno() if errno == errno.EACCES: - raise SocketEACCESError() + raise SocketError(SocketEACCESError()) elif errno == errno.EAFNOSUPPORT: - raise SocketEAFNOSUPPORTError() + raise SocketError(SocketEAFNOSUPPORTError()) elif errno == errno.EINVAL: - raise SocketEINVALError() + raise SocketError(SocketEINVALError()) elif errno == errno.EMFILE: - raise SocketEMFILEError() + raise SocketError(SocketEMFILEError()) elif errno == errno.ENFILE: - raise SocketENFILEError() + raise SocketError(SocketENFILEError()) elif errno in [errno.ENOBUFS, errno.ENOMEM]: - raise SocketENOBUFSError() + raise SocketError(SocketENOBUFSError()) elif errno == errno.EPROTONOSUPPORT: - raise SocketEPROTONOSUPPORTError() + raise SocketError(SocketEPROTONOSUPPORTError()) return fd @@ -332,20 +332,20 @@ fn setsockopt( if result == -1: var errno = get_errno() if errno == errno.EBADF: - raise SetsockoptEBADFError() + raise SetsockoptError(SetsockoptEBADFError()) elif errno == errno.EFAULT: - raise SetsockoptEFAULTError() + raise SetsockoptError(SetsockoptEFAULTError()) elif errno == errno.EINVAL: - raise SetsockoptEINVALError() + raise SetsockoptError(SetsockoptEINVALError()) elif errno == errno.ENOPROTOOPT: - raise SetsockoptENOPROTOOPTError() + raise SetsockoptError(SetsockoptENOPROTOOPTError()) elif errno == errno.ENOTSOCK: - raise SetsockoptENOTSOCKError() + raise SetsockoptError(SetsockoptENOTSOCKError()) else: - raise Error( + raise SetsockoptError(Error( "SetsockoptError: An error occurred while setting the socket option. Error code: ", errno, - ) + )) fn _getsockopt[ @@ -427,20 +427,20 @@ fn getsockopt( if result == -1: var errno = get_errno() if errno == errno.EBADF: - raise GetsockoptEBADFError() + raise GetsockoptError(GetsockoptEBADFError()) elif errno == errno.EFAULT: - raise GetsockoptEFAULTError() + raise GetsockoptError(GetsockoptEFAULTError()) elif errno == errno.EINVAL: - raise GetsockoptEINVALError() + raise GetsockoptError(GetsockoptEINVALError()) elif errno == errno.ENOPROTOOPT: - raise GetsockoptENOPROTOOPTError() + raise GetsockoptError(GetsockoptENOPROTOOPTError()) elif errno == errno.ENOTSOCK: - raise GetsockoptENOTSOCKError() + raise GetsockoptError(GetsockoptENOTSOCKError()) else: - raise Error( + raise GetsockoptError(Error( "GetsockoptError: An error occurred while getting the socket option. Error code: ", errno, - ) + )) return option_value.bitcast[Int]().take_pointee() @@ -503,15 +503,15 @@ fn getsockname(socket: FileDescriptor, mut address: SocketAddress) raises Getsoc if result == -1: var errno = get_errno() if errno == errno.EBADF: - raise GetsocknameEBADFError() + raise GetsocknameError(GetsocknameEBADFError()) elif errno == errno.EFAULT: - raise GetsocknameEFAULTError() + raise GetsocknameError(GetsocknameEFAULTError()) elif errno == errno.EINVAL: - raise GetsocknameEINVALError() + raise GetsocknameError(GetsocknameEINVALError()) elif errno == errno.ENOBUFS: - raise GetsocknameENOBUFSError() + raise GetsocknameError(GetsocknameENOBUFSError()) elif errno == errno.ENOTSOCK: - raise GetsocknameENOTSOCKError() + raise GetsocknameError(GetsocknameENOTSOCKError()) fn _getpeername[ @@ -577,17 +577,17 @@ fn getpeername(file_descriptor: FileDescriptor) raises GetpeernameError -> Socke if result == -1: var errno = get_errno() if errno == errno.EBADF: - raise GetpeernameEBADFError() + raise GetpeernameError(GetpeernameEBADFError()) elif errno == errno.EFAULT: - raise GetpeernameEFAULTError() + raise GetpeernameError(GetpeernameEFAULTError()) elif errno == errno.EINVAL: - raise GetpeernameEINVALError() + raise GetpeernameError(GetpeernameEINVALError()) elif errno == errno.ENOBUFS: - raise GetpeernameENOBUFSError() + raise GetpeernameError(GetpeernameENOBUFSError()) elif errno == errno.ENOTCONN: - raise GetpeernameENOTCONNError() + raise GetpeernameError(GetpeernameENOTCONNError()) elif errno == errno.ENOTSOCK: - raise GetpeernameENOTSOCKError() + raise GetpeernameError(GetpeernameENOTSOCKError()) return remote_address^ @@ -656,25 +656,25 @@ fn bind(socket: FileDescriptor, mut address: SocketAddress) raises BindError: if result == -1: var errno = get_errno() if errno == errno.EACCES: - raise BindEACCESError() + raise BindError(BindEACCESError()) elif errno == errno.EADDRINUSE: - raise BindEADDRINUSEError() + raise BindError(BindEADDRINUSEError()) elif errno == errno.EBADF: - raise BindEBADFError() + raise BindError(BindEBADFError()) elif errno == errno.EINVAL: - raise BindEINVALError() + raise BindError(BindEINVALError()) elif errno == errno.ENOTSOCK: - raise BindENOTSOCKError() + raise BindError(BindENOTSOCKError()) # The following errors are specific to UNIX domain (AF_UNIX) sockets. TODO: Pass address_family when unix sockets supported. # if address_family == AF_UNIX: # if errno == errno.EACCES: # raise BindEACCESError() - raise Error( + raise BindError(Error( "bind: An error occurred while binding the socket. Error code: ", errno, - ) + )) fn _listen(socket: c_int, backlog: c_int) -> c_int: @@ -724,13 +724,13 @@ fn listen(socket: FileDescriptor, backlog: c_int) raises ListenError: if result == -1: var errno = get_errno() if errno == errno.EADDRINUSE: - raise ListenEADDRINUSEError() + raise ListenError(ListenEADDRINUSEError()) elif errno == errno.EBADF: - raise ListenEBADFError() + raise ListenError(ListenEBADFError()) elif errno == errno.ENOTSOCK: - raise ListenENOTSOCKError() + raise ListenError(ListenENOTSOCKError()) elif errno == errno.EOPNOTSUPP: - raise ListenEOPNOTSUPPError() + raise ListenError(ListenEOPNOTSUPPError()) fn _accept[ @@ -798,34 +798,34 @@ fn accept(socket: FileDescriptor) raises AcceptError -> FileDescriptor: if result == -1: var errno = get_errno() if errno in [errno.EAGAIN, errno.EWOULDBLOCK]: - raise AcceptEAGAINError() + raise AcceptError(AcceptEAGAINError()) elif errno == errno.EBADF: - raise AcceptEBADFError() + raise AcceptError(AcceptEBADFError()) elif errno == errno.ECONNABORTED: - raise AcceptECONNABORTEDError() + raise AcceptError(AcceptECONNABORTEDError()) elif errno == errno.EFAULT: - raise AcceptEFAULTError() + raise AcceptError(AcceptEFAULTError()) elif errno == errno.EINTR: - raise AcceptEINTRError() + raise AcceptError(AcceptEINTRError()) elif errno == errno.EINVAL: - raise AcceptEINVALError() + raise AcceptError(AcceptEINVALError()) elif errno == errno.EMFILE: - raise AcceptEMFILEError() + raise AcceptError(AcceptEMFILEError()) elif errno == errno.ENFILE: - raise AcceptENFILEError() + raise AcceptError(AcceptENFILEError()) elif errno in [errno.ENOBUFS, errno.ENOMEM]: - raise AcceptENOBUFSError() + raise AcceptError(AcceptENOBUFSError()) elif errno == errno.ENOTSOCK: - raise AcceptENOTSOCKError() + raise AcceptError(AcceptENOTSOCKError()) elif errno == errno.EOPNOTSUPP: - raise AcceptEOPNOTSUPPError() + raise AcceptError(AcceptEOPNOTSUPPError()) elif errno == errno.EPROTO: - raise AcceptEPROTOError() + raise AcceptError(AcceptEPROTOError()) @parameter if CompilationTarget.is_linux(): if errno == errno.EPERM: - raise AcceptEPERMError() + raise AcceptError(AcceptEPERMError()) return FileDescriptor(Int(result)) @@ -894,33 +894,33 @@ fn connect(socket: FileDescriptor, mut address: SocketAddress) raises ConnectErr if result == -1: var errno = get_errno() if errno == errno.EACCES: - raise ConnectEACCESError() + raise ConnectError(ConnectEACCESError()) elif errno == errno.EADDRINUSE: - raise ConnectEADDRINUSEError() + raise ConnectError(ConnectEADDRINUSEError()) elif errno == errno.EAGAIN: - raise ConnectEAGAINError() + raise ConnectError(ConnectEAGAINError()) elif errno == errno.EALREADY: - raise ConnectEALREADYError() + raise ConnectError(ConnectEALREADYError()) elif errno == errno.EBADF: - raise ConnectEBADFError() + raise ConnectError(ConnectEBADFError()) elif errno == errno.ECONNREFUSED: - raise ConnectECONNREFUSEDError() + raise ConnectError(ConnectECONNREFUSEDError()) elif errno == errno.EFAULT: - raise ConnectEFAULTError() + raise ConnectError(ConnectEFAULTError()) elif errno == errno.EINPROGRESS: - raise ConnectEINPROGRESSError() + raise ConnectError(ConnectEINPROGRESSError()) elif errno == errno.EINTR: - raise ConnectEINTRError() + raise ConnectError(ConnectEINTRError()) elif errno == errno.EISCONN: - raise ConnectEISCONNError() + raise ConnectError(ConnectEISCONNError()) elif errno == errno.ENETUNREACH: - raise ConnectENETUNREACHError() + raise ConnectError(ConnectENETUNREACHError()) elif errno == errno.ENOTSOCK: - raise ConnectENOTSOCKError() + raise ConnectError(ConnectENOTSOCKError()) elif errno == errno.EAFNOSUPPORT: - raise ConnectEAFNOSUPPORTError() + raise ConnectError(ConnectEAFNOSUPPORTError()) elif errno == errno.ETIMEDOUT: - raise ConnectETIMEDOUTError() + raise ConnectError(ConnectETIMEDOUTError()) fn _recv( @@ -987,24 +987,24 @@ fn recv[ if result == -1: var errno = get_errno() if errno in [errno.EAGAIN, errno.EWOULDBLOCK]: - raise RecvEAGAINError() + raise RecvError(RecvEAGAINError()) elif errno == errno.EBADF: - raise RecvEBADFError() + raise RecvError(RecvEBADFError()) elif errno == errno.ECONNREFUSED: - raise RecvECONNREFUSEDError() + raise RecvError(RecvECONNREFUSEDError()) elif errno == errno.EFAULT: - raise RecvEFAULTError() + raise RecvError(RecvEFAULTError()) elif errno == errno.EINTR: - raise RecvEINTRError() + raise RecvError(RecvEINTRError()) elif errno == errno.ENOTCONN: - raise RecvENOTCONNError() + raise RecvError(RecvENOTCONNError()) elif errno == errno.ENOTSOCK: - raise RecvENOTSOCKError() + raise RecvError(RecvENOTSOCKError()) else: - raise Error( + raise RecvError(Error( "RecvError: An error occurred while attempting to receive data from the socket. Error code: ", errno, - ) + )) return UInt(result) @@ -1109,34 +1109,34 @@ fn recvfrom[ if result == -1: var errno = get_errno() if errno in [errno.EAGAIN, errno.EWOULDBLOCK]: - raise RecvfromEAGAINError() + raise RecvfromError(RecvfromEAGAINError()) elif errno == errno.EBADF: - raise RecvfromEBADFError() + raise RecvfromError(RecvfromEBADFError()) elif errno == errno.ECONNRESET: - raise RecvfromECONNRESETError() + raise RecvfromError(RecvfromECONNRESETError()) elif errno == errno.EINTR: - raise RecvfromEINTRError() + raise RecvfromError(RecvfromEINTRError()) elif errno == errno.EINVAL: - raise RecvfromEINVALError() + raise RecvfromError(RecvfromEINVALError()) elif errno == errno.ENOTCONN: - raise RecvfromENOTCONNError() + raise RecvfromError(RecvfromENOTCONNError()) elif errno == errno.ENOTSOCK: - raise RecvfromENOTSOCKError() + raise RecvfromError(RecvfromENOTSOCKError()) elif errno == errno.EOPNOTSUPP: - raise RecvfromEOPNOTSUPPError() + raise RecvfromError(RecvfromEOPNOTSUPPError()) elif errno == errno.ETIMEDOUT: - raise RecvfromETIMEDOUTError() + raise RecvfromError(RecvfromETIMEDOUTError()) elif errno == errno.EIO: - raise RecvfromEIOError() + raise RecvfromError(RecvfromEIOError()) elif errno == errno.ENOBUFS: - raise RecvfromENOBUFSError() + raise RecvfromError(RecvfromENOBUFSError()) elif errno == errno.ENOMEM: - raise RecvfromENOMEMError() + raise RecvfromError(RecvfromENOMEMError()) else: - raise Error( + raise RecvfromError(Error( "RecvfromError: An error occurred while attempting to receive data from the socket. Error code: ", errno, - ) + )) return UInt(result) @@ -1221,38 +1221,38 @@ fn send[ if result == -1: var errno = get_errno() if errno in [errno.EAGAIN, errno.EWOULDBLOCK]: - raise SendEAGAINError() + raise SendError(SendEAGAINError()) elif errno == errno.EBADF: - raise SendEBADFError() + raise SendError(SendEBADFError()) elif errno == errno.ECONNRESET: - raise SendECONNRESETError() + raise SendError(SendECONNRESETError()) elif errno == errno.EDESTADDRREQ: - raise SendEDESTADDRREQError() + raise SendError(SendEDESTADDRREQError()) elif errno == errno.ECONNREFUSED: - raise SendECONNREFUSEDError() + raise SendError(SendECONNREFUSEDError()) elif errno == errno.EFAULT: - raise SendEFAULTError() + raise SendError(SendEFAULTError()) elif errno == errno.EINTR: - raise SendEINTRError() + raise SendError(SendEINTRError()) elif errno == errno.EINVAL: - raise SendEINVALError() + raise SendError(SendEINVALError()) elif errno == errno.EISCONN: - raise SendEISCONNError() + raise SendError(SendEISCONNError()) elif errno == errno.ENOBUFS: - raise SendENOBUFSError() + raise SendError(SendENOBUFSError()) elif errno == errno.ENOMEM: - raise SendENOMEMError() + raise SendError(SendENOMEMError()) elif errno == errno.ENOTCONN: - raise SendENOTCONNError() + raise SendError(SendENOTCONNError()) elif errno == errno.ENOTSOCK: - raise SendENOTSOCKError() + raise SendError(SendENOTSOCKError()) elif errno == errno.EOPNOTSUPP: - raise SendEOPNOTSUPPError() + raise SendError(SendEOPNOTSUPPError()) else: - raise Error( + raise SendError(Error( "SendError: An error occurred while attempting to send data to the socket. Error code: ", errno, - ) + )) return UInt(result) @@ -1351,52 +1351,52 @@ fn sendto[ if result == -1: var errno = get_errno() if errno == errno.EAFNOSUPPORT: - raise SendtoEAFNOSUPPORTError() + raise SendtoError(SendtoEAFNOSUPPORTError()) elif errno in [errno.EAGAIN, errno.EWOULDBLOCK]: - raise SendtoEAGAINError() + raise SendtoError(SendtoEAGAINError()) elif errno == errno.EBADF: - raise SendtoEBADFError() + raise SendtoError(SendtoEBADFError()) elif errno == errno.ECONNRESET: - raise SendtoECONNRESETError() + raise SendtoError(SendtoECONNRESETError()) elif errno == errno.EINTR: - raise SendtoEINTRError() + raise SendtoError(SendtoEINTRError()) elif errno == errno.EMSGSIZE: - raise SendtoEMSGSIZEError() + raise SendtoError(SendtoEMSGSIZEError()) elif errno == errno.ENOTCONN: - raise SendtoENOTCONNError() + raise SendtoError(SendtoENOTCONNError()) elif errno == errno.ENOTSOCK: - raise SendtoENOTSOCKError() + raise SendtoError(SendtoENOTSOCKError()) elif errno == errno.EPIPE: - raise SendtoEPIPEError() + raise SendtoError(SendtoEPIPEError()) elif errno == errno.EACCES: - raise SendtoEACCESError() + raise SendtoError(SendtoEACCESError()) elif errno == errno.EDESTADDRREQ: - raise SendtoEDESTADDRREQError() + raise SendtoError(SendtoEDESTADDRREQError()) elif errno == errno.EHOSTUNREACH: - raise SendtoEHOSTUNREACHError() + raise SendtoError(SendtoEHOSTUNREACHError()) elif errno == errno.EINVAL: - raise SendtoEINVALError() + raise SendtoError(SendtoEINVALError()) elif errno == errno.EIO: - raise SendtoEIOError() + raise SendtoError(SendtoEIOError()) elif errno == errno.EISCONN: - raise SendtoEISCONNError() + raise SendtoError(SendtoEISCONNError()) elif errno == errno.ENETDOWN: - raise SendtoENETDOWNError() + raise SendtoError(SendtoENETDOWNError()) elif errno == errno.ENETUNREACH: - raise SendtoENETUNREACHError() + raise SendtoError(SendtoENETUNREACHError()) elif errno == errno.ENOBUFS: - raise SendtoENOBUFSError() + raise SendtoError(SendtoENOBUFSError()) elif errno == errno.ENOMEM: - raise SendtoENOMEMError() + raise SendtoError(SendtoENOMEMError()) elif errno == errno.ELOOP: - raise SendtoELOOPError() + raise SendtoError(SendtoELOOPError()) elif errno == errno.ENAMETOOLONG: - raise SendtoENAMETOOLONGError() + raise SendtoError(SendtoENAMETOOLONGError()) else: - raise Error( + raise SendtoError(Error( "SendtoError: An error occurred while attempting to send data to the socket. Error code: ", errno, - ) + )) return UInt(result) @@ -1448,13 +1448,13 @@ fn shutdown(socket: FileDescriptor, how: ShutdownOption) raises ShutdownError: if result == -1: var errno = get_errno() if errno == errno.EBADF: - raise ShutdownEBADFError() + raise ShutdownError(ShutdownEBADFError()) elif errno == errno.EINVAL: - raise ShutdownEINVALError() + raise ShutdownError(ShutdownEINVALError()) elif errno == errno.ENOTCONN: - raise ShutdownENOTCONNError() + raise ShutdownError(ShutdownENOTCONNError()) elif errno == errno.ENOTSOCK: - raise ShutdownENOTSOCKError() + raise ShutdownError(ShutdownENOTSOCKError()) fn _close(fildes: c_int) -> c_int: @@ -1505,10 +1505,10 @@ fn close(file_descriptor: FileDescriptor) raises CloseError: if _close(file_descriptor.value) == -1: var errno = get_errno() if errno == errno.EBADF: - raise CloseEBADFError() + raise CloseError(CloseEBADFError()) elif errno == errno.EINTR: - raise CloseEINTRError() + raise CloseError(CloseEINTRError()) elif errno == errno.EIO: - raise CloseEIOError() + raise CloseError(CloseEIOError()) elif errno in [errno.ENOSPC, errno.EDQUOT]: - raise CloseENOSPCError() + raise CloseError(CloseENOSPCError()) diff --git a/lightbug_http/c/socket_error.mojo b/lightbug_http/c/socket_error.mojo index deec320b..edb0609b 100644 --- a/lightbug_http/c/socket_error.mojo +++ b/lightbug_http/c/socket_error.mojo @@ -4,8 +4,6 @@ Generated from socket.mojo error handling patterns. Follows the pattern from typed_errors.mojo. """ -from ffi import c_int, external_call, get_errno - from lightbug_http.utils.error import CustomError from utils import Variant @@ -1455,1266 +1453,186 @@ struct SocketEPROTONOSUPPORTError(CustomError, TrivialRegisterPassable): return Self.message -@fieldwise_init -struct AcceptError(Movable, Stringable, Writable): - """Typed error variant for accept() function.""" - - comptime type = Variant[ - AcceptEBADFError, - AcceptEINTRError, - AcceptEAGAINError, - AcceptECONNABORTEDError, - AcceptEFAULTError, - AcceptEINVALError, - AcceptEMFILEError, - AcceptENFILEError, - AcceptENOBUFSError, - AcceptENOTSOCKError, - AcceptEOPNOTSUPPError, - AcceptEPERMError, - AcceptEPROTOError, - Error, - ] - var value: Self.type - - @implicit - fn __init__(out self, value: AcceptEBADFError): - self.value = value - - @implicit - fn __init__(out self, value: AcceptEINTRError): - self.value = value - - @implicit - fn __init__(out self, value: AcceptEAGAINError): - self.value = value - - @implicit - fn __init__(out self, value: AcceptECONNABORTEDError): - self.value = value - - @implicit - fn __init__(out self, value: AcceptEFAULTError): - self.value = value - - @implicit - fn __init__(out self, value: AcceptEINVALError): - self.value = value - - @implicit - fn __init__(out self, value: AcceptEMFILEError): - self.value = value - - @implicit - fn __init__(out self, value: AcceptENFILEError): - self.value = value - - @implicit - fn __init__(out self, value: AcceptENOBUFSError): - self.value = value - - @implicit - fn __init__(out self, value: AcceptENOTSOCKError): - self.value = value - - @implicit - fn __init__(out self, value: AcceptEOPNOTSUPPError): - self.value = value - - @implicit - fn __init__(out self, value: AcceptEPERMError): - self.value = value - - @implicit - fn __init__(out self, value: AcceptEPROTOError): - self.value = value - - @implicit - fn __init__(out self, var value: Error): - self.value = value^ - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[AcceptEBADFError](): - writer.write(self.value[AcceptEBADFError]) - elif self.value.isa[AcceptEINTRError](): - writer.write(self.value[AcceptEINTRError]) - elif self.value.isa[AcceptEAGAINError](): - writer.write(self.value[AcceptEAGAINError]) - elif self.value.isa[AcceptECONNABORTEDError](): - writer.write(self.value[AcceptECONNABORTEDError]) - elif self.value.isa[AcceptEFAULTError](): - writer.write(self.value[AcceptEFAULTError]) - elif self.value.isa[AcceptEINVALError](): - writer.write(self.value[AcceptEINVALError]) - elif self.value.isa[AcceptEMFILEError](): - writer.write(self.value[AcceptEMFILEError]) - elif self.value.isa[AcceptENFILEError](): - writer.write(self.value[AcceptENFILEError]) - elif self.value.isa[AcceptENOBUFSError](): - writer.write(self.value[AcceptENOBUFSError]) - elif self.value.isa[AcceptENOTSOCKError](): - writer.write(self.value[AcceptENOTSOCKError]) - elif self.value.isa[AcceptEOPNOTSUPPError](): - writer.write(self.value[AcceptEOPNOTSUPPError]) - elif self.value.isa[AcceptEPERMError](): - writer.write(self.value[AcceptEPERMError]) - elif self.value.isa[AcceptEPROTOError](): - writer.write(self.value[AcceptEPROTOError]) - elif self.value.isa[Error](): - writer.write(self.value[Error]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) - - -@fieldwise_init -struct BindError(Movable, Stringable, Writable): - """Typed error variant for bind() function.""" - - comptime type = Variant[ - BindEACCESError, - BindEADDRINUSEError, - BindEBADFError, - BindEFAULTError, - BindEINVALError, - BindELOOPError, - BindENAMETOOLONGError, - BindENOMEMError, - BindENOTSOCKError, - Error, - ] - var value: Self.type - - @implicit - fn __init__(out self, value: BindEACCESError): - self.value = value - - @implicit - fn __init__(out self, value: BindEADDRINUSEError): - self.value = value - - @implicit - fn __init__(out self, value: BindEBADFError): - self.value = value - - @implicit - fn __init__(out self, value: BindEFAULTError): - self.value = value - - @implicit - fn __init__(out self, value: BindEINVALError): - self.value = value - - @implicit - fn __init__(out self, value: BindELOOPError): - self.value = value - - @implicit - fn __init__(out self, value: BindENAMETOOLONGError): - self.value = value - - @implicit - fn __init__(out self, value: BindENOMEMError): - self.value = value - - @implicit - fn __init__(out self, value: BindENOTSOCKError): - self.value = value - - @implicit - fn __init__(out self, var value: Error): - self.value = value^ - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[BindEACCESError](): - writer.write(self.value[BindEACCESError]) - elif self.value.isa[BindEADDRINUSEError](): - writer.write(self.value[BindEADDRINUSEError]) - elif self.value.isa[BindEBADFError](): - writer.write(self.value[BindEBADFError]) - elif self.value.isa[BindEFAULTError](): - writer.write(self.value[BindEFAULTError]) - elif self.value.isa[BindEINVALError](): - writer.write(self.value[BindEINVALError]) - elif self.value.isa[BindELOOPError](): - writer.write(self.value[BindELOOPError]) - elif self.value.isa[BindENAMETOOLONGError](): - writer.write(self.value[BindENAMETOOLONGError]) - elif self.value.isa[BindENOMEMError](): - writer.write(self.value[BindENOMEMError]) - elif self.value.isa[BindENOTSOCKError](): - writer.write(self.value[BindENOTSOCKError]) - elif self.value.isa[Error](): - writer.write(self.value[Error]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) - - -@fieldwise_init -struct CloseError(Movable, Stringable, Writable): - """Typed error variant for close() function.""" - - comptime type = Variant[CloseEBADFError, CloseEINTRError, CloseEIOError, CloseENOSPCError] - var value: Self.type - - @implicit - fn __init__(out self, value: CloseEBADFError): - self.value = value - - @implicit - fn __init__(out self, value: CloseEINTRError): - self.value = value - - @implicit - fn __init__(out self, value: CloseEIOError): - self.value = value - - @implicit - fn __init__(out self, value: CloseENOSPCError): - self.value = value - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[CloseEBADFError](): - writer.write(self.value[CloseEBADFError]) - elif self.value.isa[CloseEINTRError](): - writer.write(self.value[CloseEINTRError]) - elif self.value.isa[CloseEIOError](): - writer.write(self.value[CloseEIOError]) - elif self.value.isa[CloseENOSPCError](): - writer.write(self.value[CloseENOSPCError]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) - - -@fieldwise_init -struct ConnectError(Movable, Stringable, Writable): - """Typed error variant for connect() function.""" - - comptime type = Variant[ - ConnectEACCESError, - ConnectEADDRINUSEError, - ConnectEAFNOSUPPORTError, - ConnectEAGAINError, - ConnectEALREADYError, - ConnectEBADFError, - ConnectECONNREFUSEDError, - ConnectEFAULTError, - ConnectEINPROGRESSError, - ConnectEINTRError, - ConnectEISCONNError, - ConnectENETUNREACHError, - ConnectENOTSOCKError, - ConnectETIMEDOUTError, - Error, - ] - var value: Self.type - - @implicit - fn __init__(out self, value: ConnectEACCESError): - self.value = value - - @implicit - fn __init__(out self, value: ConnectEADDRINUSEError): - self.value = value - - @implicit - fn __init__(out self, value: ConnectEAFNOSUPPORTError): - self.value = value - - @implicit - fn __init__(out self, value: ConnectEAGAINError): - self.value = value - - @implicit - fn __init__(out self, value: ConnectEALREADYError): - self.value = value - - @implicit - fn __init__(out self, value: ConnectEBADFError): - self.value = value - - @implicit - fn __init__(out self, value: ConnectECONNREFUSEDError): - self.value = value - - @implicit - fn __init__(out self, value: ConnectEFAULTError): - self.value = value - - @implicit - fn __init__(out self, value: ConnectEINPROGRESSError): - self.value = value - - @implicit - fn __init__(out self, value: ConnectEINTRError): - self.value = value - - @implicit - fn __init__(out self, value: ConnectEISCONNError): - self.value = value - - @implicit - fn __init__(out self, value: ConnectENETUNREACHError): - self.value = value - - @implicit - fn __init__(out self, value: ConnectENOTSOCKError): - self.value = value - - @implicit - fn __init__(out self, value: ConnectETIMEDOUTError): - self.value = value - - @implicit - fn __init__(out self, var value: Error): - self.value = value^ - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[ConnectEACCESError](): - writer.write(self.value[ConnectEACCESError]) - elif self.value.isa[ConnectEADDRINUSEError](): - writer.write(self.value[ConnectEADDRINUSEError]) - elif self.value.isa[ConnectEAFNOSUPPORTError](): - writer.write(self.value[ConnectEAFNOSUPPORTError]) - elif self.value.isa[ConnectEAGAINError](): - writer.write(self.value[ConnectEAGAINError]) - elif self.value.isa[ConnectEALREADYError](): - writer.write(self.value[ConnectEALREADYError]) - elif self.value.isa[ConnectEBADFError](): - writer.write(self.value[ConnectEBADFError]) - elif self.value.isa[ConnectECONNREFUSEDError](): - writer.write(self.value[ConnectECONNREFUSEDError]) - elif self.value.isa[ConnectEFAULTError](): - writer.write(self.value[ConnectEFAULTError]) - elif self.value.isa[ConnectEINPROGRESSError](): - writer.write(self.value[ConnectEINPROGRESSError]) - elif self.value.isa[ConnectEINTRError](): - writer.write(self.value[ConnectEINTRError]) - elif self.value.isa[ConnectEISCONNError](): - writer.write(self.value[ConnectEISCONNError]) - elif self.value.isa[ConnectENETUNREACHError](): - writer.write(self.value[ConnectENETUNREACHError]) - elif self.value.isa[ConnectENOTSOCKError](): - writer.write(self.value[ConnectENOTSOCKError]) - elif self.value.isa[ConnectETIMEDOUTError](): - writer.write(self.value[ConnectETIMEDOUTError]) - elif self.value.isa[Error](): - writer.write(self.value[Error]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) - - -@fieldwise_init -struct GetpeernameError(Movable, Stringable, Writable): - """Typed error variant for getpeername() function.""" - - comptime type = Variant[ - GetpeernameEBADFError, - GetpeernameEFAULTError, - GetpeernameEINVALError, - GetpeernameENOBUFSError, - GetpeernameENOTCONNError, - GetpeernameENOTSOCKError, - ] - var value: Self.type - - @implicit - fn __init__(out self, value: GetpeernameEBADFError): - self.value = value - - @implicit - fn __init__(out self, value: GetpeernameEFAULTError): - self.value = value - - @implicit - fn __init__(out self, value: GetpeernameEINVALError): - self.value = value - - @implicit - fn __init__(out self, value: GetpeernameENOBUFSError): - self.value = value - - @implicit - fn __init__(out self, value: GetpeernameENOTCONNError): - self.value = value - - @implicit - fn __init__(out self, value: GetpeernameENOTSOCKError): - self.value = value - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[GetpeernameEBADFError](): - writer.write(self.value[GetpeernameEBADFError]) - elif self.value.isa[GetpeernameEFAULTError](): - writer.write(self.value[GetpeernameEFAULTError]) - elif self.value.isa[GetpeernameEINVALError](): - writer.write(self.value[GetpeernameEINVALError]) - elif self.value.isa[GetpeernameENOBUFSError](): - writer.write(self.value[GetpeernameENOBUFSError]) - elif self.value.isa[GetpeernameENOTCONNError](): - writer.write(self.value[GetpeernameENOTCONNError]) - elif self.value.isa[GetpeernameENOTSOCKError](): - writer.write(self.value[GetpeernameENOTSOCKError]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) - - -@fieldwise_init -struct GetsocknameError(Movable, Stringable, Writable): - """Typed error variant for getsockname() function.""" - - comptime type = Variant[ - GetsocknameEBADFError, - GetsocknameEFAULTError, - GetsocknameEINVALError, - GetsocknameENOBUFSError, - GetsocknameENOTSOCKError, - ] - var value: Self.type - - @implicit - fn __init__(out self, value: GetsocknameEBADFError): - self.value = value - - @implicit - fn __init__(out self, value: GetsocknameEFAULTError): - self.value = value - - @implicit - fn __init__(out self, value: GetsocknameEINVALError): - self.value = value - - @implicit - fn __init__(out self, value: GetsocknameENOBUFSError): - self.value = value - - @implicit - fn __init__(out self, value: GetsocknameENOTSOCKError): - self.value = value - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[GetsocknameEBADFError](): - writer.write(self.value[GetsocknameEBADFError]) - elif self.value.isa[GetsocknameEFAULTError](): - writer.write(self.value[GetsocknameEFAULTError]) - elif self.value.isa[GetsocknameEINVALError](): - writer.write(self.value[GetsocknameEINVALError]) - elif self.value.isa[GetsocknameENOBUFSError](): - writer.write(self.value[GetsocknameENOBUFSError]) - elif self.value.isa[GetsocknameENOTSOCKError](): - writer.write(self.value[GetsocknameENOTSOCKError]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) - - -@fieldwise_init -struct GetsockoptError(Movable, Stringable, Writable): - """Typed error variant for getsockopt() function.""" - - comptime type = Variant[ - GetsockoptEBADFError, - GetsockoptEFAULTError, - GetsockoptEINVALError, - GetsockoptENOPROTOOPTError, - GetsockoptENOTSOCKError, - Error, - ] - var value: Self.type - - @implicit - fn __init__(out self, value: GetsockoptEBADFError): - self.value = value - - @implicit - fn __init__(out self, value: GetsockoptEFAULTError): - self.value = value - - @implicit - fn __init__(out self, value: GetsockoptEINVALError): - self.value = value - - @implicit - fn __init__(out self, value: GetsockoptENOPROTOOPTError): - self.value = value - - @implicit - fn __init__(out self, value: GetsockoptENOTSOCKError): - self.value = value - - @implicit - fn __init__(out self, var value: Error): - self.value = value^ - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[GetsockoptEBADFError](): - writer.write(self.value[GetsockoptEBADFError]) - elif self.value.isa[GetsockoptEFAULTError](): - writer.write(self.value[GetsockoptEFAULTError]) - elif self.value.isa[GetsockoptEINVALError](): - writer.write(self.value[GetsockoptEINVALError]) - elif self.value.isa[GetsockoptENOPROTOOPTError](): - writer.write(self.value[GetsockoptENOPROTOOPTError]) - elif self.value.isa[GetsockoptENOTSOCKError](): - writer.write(self.value[GetsockoptENOTSOCKError]) - elif self.value.isa[Error](): - writer.write(self.value[Error]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) - - -@fieldwise_init -struct ListenError(Movable, Stringable, Writable): - """Typed error variant for listen() function.""" - - comptime type = Variant[ListenEADDRINUSEError, ListenEBADFError, ListenENOTSOCKError, ListenEOPNOTSUPPError] - var value: Self.type - - @implicit - fn __init__(out self, value: ListenEADDRINUSEError): - self.value = value - - @implicit - fn __init__(out self, value: ListenEBADFError): - self.value = value - - @implicit - fn __init__(out self, value: ListenENOTSOCKError): - self.value = value - - @implicit - fn __init__(out self, value: ListenEOPNOTSUPPError): - self.value = value - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[ListenEADDRINUSEError](): - writer.write(self.value[ListenEADDRINUSEError]) - elif self.value.isa[ListenEBADFError](): - writer.write(self.value[ListenEBADFError]) - elif self.value.isa[ListenENOTSOCKError](): - writer.write(self.value[ListenENOTSOCKError]) - elif self.value.isa[ListenEOPNOTSUPPError](): - writer.write(self.value[ListenEOPNOTSUPPError]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) - - -@fieldwise_init -struct RecvError(Movable, Stringable, Writable): - """Typed error variant for recv() function.""" - - comptime type = Variant[ - RecvEAGAINError, - RecvEBADFError, - RecvECONNREFUSEDError, - RecvEFAULTError, - RecvEINTRError, - RecvENOTCONNError, - RecvENOTSOCKError, - Error, - ] - var value: Self.type - - @implicit - fn __init__(out self, value: RecvEAGAINError): - self.value = value - - @implicit - fn __init__(out self, value: RecvEBADFError): - self.value = value - - @implicit - fn __init__(out self, value: RecvECONNREFUSEDError): - self.value = value - - @implicit - fn __init__(out self, value: RecvEFAULTError): - self.value = value - - @implicit - fn __init__(out self, value: RecvEINTRError): - self.value = value - - @implicit - fn __init__(out self, value: RecvENOTCONNError): - self.value = value - - @implicit - fn __init__(out self, value: RecvENOTSOCKError): - self.value = value - - @implicit - fn __init__(out self, var value: Error): - self.value = value^ - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[RecvEAGAINError](): - writer.write(self.value[RecvEAGAINError]) - elif self.value.isa[RecvEBADFError](): - writer.write(self.value[RecvEBADFError]) - elif self.value.isa[RecvECONNREFUSEDError](): - writer.write(self.value[RecvECONNREFUSEDError]) - elif self.value.isa[RecvEFAULTError](): - writer.write(self.value[RecvEFAULTError]) - elif self.value.isa[RecvEINTRError](): - writer.write(self.value[RecvEINTRError]) - elif self.value.isa[RecvENOTCONNError](): - writer.write(self.value[RecvENOTCONNError]) - elif self.value.isa[RecvENOTSOCKError](): - writer.write(self.value[RecvENOTSOCKError]) - elif self.value.isa[Error](): - writer.write(self.value[Error]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) - - -@fieldwise_init -struct RecvfromError(Movable, Stringable, Writable): - """Typed error variant for recvfrom() function.""" - - comptime type = Variant[ - RecvfromEAGAINError, - RecvfromEBADFError, - RecvfromECONNRESETError, - RecvfromEINTRError, - RecvfromEINVALError, - RecvfromEIOError, - RecvfromENOBUFSError, - RecvfromENOMEMError, - RecvfromENOTCONNError, - RecvfromENOTSOCKError, - RecvfromEOPNOTSUPPError, - RecvfromETIMEDOUTError, - Error, - ] - var value: Self.type - - @implicit - fn __init__(out self, value: RecvfromEAGAINError): - self.value = value - - @implicit - fn __init__(out self, value: RecvfromEBADFError): - self.value = value - - @implicit - fn __init__(out self, value: RecvfromECONNRESETError): - self.value = value - - @implicit - fn __init__(out self, value: RecvfromEINTRError): - self.value = value - - @implicit - fn __init__(out self, value: RecvfromEINVALError): - self.value = value - - @implicit - fn __init__(out self, value: RecvfromEIOError): - self.value = value - - @implicit - fn __init__(out self, value: RecvfromENOBUFSError): - self.value = value - - @implicit - fn __init__(out self, value: RecvfromENOMEMError): - self.value = value - - @implicit - fn __init__(out self, value: RecvfromENOTCONNError): - self.value = value - - @implicit - fn __init__(out self, value: RecvfromENOTSOCKError): - self.value = value - - @implicit - fn __init__(out self, value: RecvfromEOPNOTSUPPError): - self.value = value - - @implicit - fn __init__(out self, value: RecvfromETIMEDOUTError): - self.value = value - - @implicit - fn __init__(out self, var value: Error): - self.value = value^ - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[RecvfromEAGAINError](): - writer.write(self.value[RecvfromEAGAINError]) - elif self.value.isa[RecvfromEBADFError](): - writer.write(self.value[RecvfromEBADFError]) - elif self.value.isa[RecvfromECONNRESETError](): - writer.write(self.value[RecvfromECONNRESETError]) - elif self.value.isa[RecvfromEINTRError](): - writer.write(self.value[RecvfromEINTRError]) - elif self.value.isa[RecvfromEINVALError](): - writer.write(self.value[RecvfromEINVALError]) - elif self.value.isa[RecvfromEIOError](): - writer.write(self.value[RecvfromEIOError]) - elif self.value.isa[RecvfromENOBUFSError](): - writer.write(self.value[RecvfromENOBUFSError]) - elif self.value.isa[RecvfromENOMEMError](): - writer.write(self.value[RecvfromENOMEMError]) - elif self.value.isa[RecvfromENOTCONNError](): - writer.write(self.value[RecvfromENOTCONNError]) - elif self.value.isa[RecvfromENOTSOCKError](): - writer.write(self.value[RecvfromENOTSOCKError]) - elif self.value.isa[RecvfromEOPNOTSUPPError](): - writer.write(self.value[RecvfromEOPNOTSUPPError]) - elif self.value.isa[RecvfromETIMEDOUTError](): - writer.write(self.value[RecvfromETIMEDOUTError]) - elif self.value.isa[Error](): - writer.write(self.value[Error]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) - - -@fieldwise_init -struct SendError(Movable, Stringable, Writable): - """Typed error variant for send() function.""" - - comptime type = Variant[ - SendEAGAINError, - SendEBADFError, - SendECONNREFUSEDError, - SendECONNRESETError, - SendEDESTADDRREQError, - SendEFAULTError, - SendEINTRError, - SendEINVALError, - SendEISCONNError, - SendENOBUFSError, - SendENOMEMError, - SendENOTCONNError, - SendENOTSOCKError, - SendEOPNOTSUPPError, - Error, - ] - var value: Self.type - - @implicit - fn __init__(out self, value: SendEAGAINError): - self.value = value - - @implicit - fn __init__(out self, value: SendEBADFError): - self.value = value - - @implicit - fn __init__(out self, value: SendECONNREFUSEDError): - self.value = value - - @implicit - fn __init__(out self, value: SendECONNRESETError): - self.value = value - - @implicit - fn __init__(out self, value: SendEDESTADDRREQError): - self.value = value - - @implicit - fn __init__(out self, value: SendEFAULTError): - self.value = value - - @implicit - fn __init__(out self, value: SendEINTRError): - self.value = value - - @implicit - fn __init__(out self, value: SendEINVALError): - self.value = value - - @implicit - fn __init__(out self, value: SendEISCONNError): - self.value = value - - @implicit - fn __init__(out self, value: SendENOBUFSError): - self.value = value - - @implicit - fn __init__(out self, value: SendENOMEMError): - self.value = value - - @implicit - fn __init__(out self, value: SendENOTCONNError): - self.value = value - - @implicit - fn __init__(out self, value: SendENOTSOCKError): - self.value = value - - @implicit - fn __init__(out self, value: SendEOPNOTSUPPError): - self.value = value - - @implicit - fn __init__(out self, var value: Error): - self.value = value^ - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[SendEAGAINError](): - writer.write(self.value[SendEAGAINError]) - elif self.value.isa[SendEBADFError](): - writer.write(self.value[SendEBADFError]) - elif self.value.isa[SendECONNREFUSEDError](): - writer.write(self.value[SendECONNREFUSEDError]) - elif self.value.isa[SendECONNRESETError](): - writer.write(self.value[SendECONNRESETError]) - elif self.value.isa[SendEDESTADDRREQError](): - writer.write(self.value[SendEDESTADDRREQError]) - elif self.value.isa[SendEFAULTError](): - writer.write(self.value[SendEFAULTError]) - elif self.value.isa[SendEINTRError](): - writer.write(self.value[SendEINTRError]) - elif self.value.isa[SendEINVALError](): - writer.write(self.value[SendEINVALError]) - elif self.value.isa[SendEISCONNError](): - writer.write(self.value[SendEISCONNError]) - elif self.value.isa[SendENOBUFSError](): - writer.write(self.value[SendENOBUFSError]) - elif self.value.isa[SendENOMEMError](): - writer.write(self.value[SendENOMEMError]) - elif self.value.isa[SendENOTCONNError](): - writer.write(self.value[SendENOTCONNError]) - elif self.value.isa[SendENOTSOCKError](): - writer.write(self.value[SendENOTSOCKError]) - elif self.value.isa[SendEOPNOTSUPPError](): - writer.write(self.value[SendEOPNOTSUPPError]) - elif self.value.isa[Error](): - writer.write(self.value[Error]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) - - -@fieldwise_init -struct SendtoError(Movable, Stringable, Writable): - """Typed error variant for sendto() function.""" - - comptime type = Variant[ - SendtoEACCESError, - SendtoEAFNOSUPPORTError, - SendtoEAGAINError, - SendtoEBADFError, - SendtoECONNRESETError, - SendtoEDESTADDRREQError, - SendtoEHOSTUNREACHError, - SendtoEINTRError, - SendtoEINVALError, - SendtoEIOError, - SendtoEISCONNError, - SendtoELOOPError, - SendtoEMSGSIZEError, - SendtoENAMETOOLONGError, - SendtoENETDOWNError, - SendtoENETUNREACHError, - SendtoENOBUFSError, - SendtoENOMEMError, - SendtoENOTCONNError, - SendtoENOTSOCKError, - SendtoEPIPEError, - Error, - ] - var value: Self.type - - @implicit - fn __init__(out self, value: SendtoEACCESError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoEAFNOSUPPORTError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoEAGAINError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoEBADFError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoECONNRESETError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoEDESTADDRREQError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoEHOSTUNREACHError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoEINTRError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoEINVALError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoEIOError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoEISCONNError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoELOOPError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoEMSGSIZEError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoENAMETOOLONGError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoENETDOWNError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoENETUNREACHError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoENOBUFSError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoENOMEMError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoENOTCONNError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoENOTSOCKError): - self.value = value - - @implicit - fn __init__(out self, value: SendtoEPIPEError): - self.value = value - - @implicit - fn __init__(out self, var value: Error): - self.value = value^ - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[SendtoEACCESError](): - writer.write(self.value[SendtoEACCESError]) - elif self.value.isa[SendtoEAFNOSUPPORTError](): - writer.write(self.value[SendtoEAFNOSUPPORTError]) - elif self.value.isa[SendtoEAGAINError](): - writer.write(self.value[SendtoEAGAINError]) - elif self.value.isa[SendtoEBADFError](): - writer.write(self.value[SendtoEBADFError]) - elif self.value.isa[SendtoECONNRESETError](): - writer.write(self.value[SendtoECONNRESETError]) - elif self.value.isa[SendtoEDESTADDRREQError](): - writer.write(self.value[SendtoEDESTADDRREQError]) - elif self.value.isa[SendtoEHOSTUNREACHError](): - writer.write(self.value[SendtoEHOSTUNREACHError]) - elif self.value.isa[SendtoEINTRError](): - writer.write(self.value[SendtoEINTRError]) - elif self.value.isa[SendtoEINVALError](): - writer.write(self.value[SendtoEINVALError]) - elif self.value.isa[SendtoEIOError](): - writer.write(self.value[SendtoEIOError]) - elif self.value.isa[SendtoEISCONNError](): - writer.write(self.value[SendtoEISCONNError]) - elif self.value.isa[SendtoELOOPError](): - writer.write(self.value[SendtoELOOPError]) - elif self.value.isa[SendtoEMSGSIZEError](): - writer.write(self.value[SendtoEMSGSIZEError]) - elif self.value.isa[SendtoENAMETOOLONGError](): - writer.write(self.value[SendtoENAMETOOLONGError]) - elif self.value.isa[SendtoENETDOWNError](): - writer.write(self.value[SendtoENETDOWNError]) - elif self.value.isa[SendtoENETUNREACHError](): - writer.write(self.value[SendtoENETUNREACHError]) - elif self.value.isa[SendtoENOBUFSError](): - writer.write(self.value[SendtoENOBUFSError]) - elif self.value.isa[SendtoENOMEMError](): - writer.write(self.value[SendtoENOMEMError]) - elif self.value.isa[SendtoENOTCONNError](): - writer.write(self.value[SendtoENOTCONNError]) - elif self.value.isa[SendtoENOTSOCKError](): - writer.write(self.value[SendtoENOTSOCKError]) - elif self.value.isa[SendtoEPIPEError](): - writer.write(self.value[SendtoEPIPEError]) - elif self.value.isa[Error](): - writer.write(self.value[Error]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) - - -@fieldwise_init -struct SetsockoptError(Movable, Stringable, Writable): - """Typed error variant for setsockopt() function.""" - - comptime type = Variant[ - SetsockoptEBADFError, - SetsockoptEFAULTError, - SetsockoptEINVALError, - SetsockoptENOPROTOOPTError, - SetsockoptENOTSOCKError, - Error, - ] - var value: Self.type - - @implicit - fn __init__(out self, value: SetsockoptEBADFError): - self.value = value - - @implicit - fn __init__(out self, value: SetsockoptEFAULTError): - self.value = value - - @implicit - fn __init__(out self, value: SetsockoptEINVALError): - self.value = value - - @implicit - fn __init__(out self, value: SetsockoptENOPROTOOPTError): - self.value = value - - @implicit - fn __init__(out self, value: SetsockoptENOTSOCKError): - self.value = value - - @implicit - fn __init__(out self, var value: Error): - self.value = value^ - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[SetsockoptEBADFError](): - writer.write(self.value[SetsockoptEBADFError]) - elif self.value.isa[SetsockoptEFAULTError](): - writer.write(self.value[SetsockoptEFAULTError]) - elif self.value.isa[SetsockoptEINVALError](): - writer.write(self.value[SetsockoptEINVALError]) - elif self.value.isa[SetsockoptENOPROTOOPTError](): - writer.write(self.value[SetsockoptENOPROTOOPTError]) - elif self.value.isa[SetsockoptENOTSOCKError](): - writer.write(self.value[SetsockoptENOTSOCKError]) - elif self.value.isa[Error](): - writer.write(self.value[Error]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) - - -@fieldwise_init -struct ShutdownError(Movable, Stringable, Writable): - """Typed error variant for shutdown() function.""" - - comptime type = Variant[ShutdownEBADFError, ShutdownEINVALError, ShutdownENOTCONNError, ShutdownENOTSOCKError] - var value: Self.type - - @implicit - fn __init__(out self, value: ShutdownEBADFError): - self.value = value - - @implicit - fn __init__(out self, value: ShutdownEINVALError): - self.value = value - - @implicit - fn __init__(out self, value: ShutdownENOTCONNError): - self.value = value - - @implicit - fn __init__(out self, value: ShutdownENOTSOCKError): - self.value = value - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[ShutdownEBADFError](): - writer.write(self.value[ShutdownEBADFError]) - elif self.value.isa[ShutdownEINVALError](): - writer.write(self.value[ShutdownEINVALError]) - elif self.value.isa[ShutdownENOTCONNError](): - writer.write(self.value[ShutdownENOTCONNError]) - elif self.value.isa[ShutdownENOTSOCKError](): - writer.write(self.value[ShutdownENOTSOCKError]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) - - -@fieldwise_init -struct SocketError(Movable, Stringable, Writable): - """Typed error variant for socket() function.""" - - comptime type = Variant[ - SocketEACCESError, - SocketEAFNOSUPPORTError, - SocketEINVALError, - SocketEMFILEError, - SocketENFILEError, - SocketENOBUFSError, - SocketEPROTONOSUPPORTError, - Error, - ] - var value: Self.type - - @implicit - fn __init__(out self, value: SocketEACCESError): - self.value = value - - @implicit - fn __init__(out self, value: SocketEAFNOSUPPORTError): - self.value = value - - @implicit - fn __init__(out self, value: SocketEINVALError): - self.value = value - - @implicit - fn __init__(out self, value: SocketEMFILEError): - self.value = value - - @implicit - fn __init__(out self, value: SocketENFILEError): - self.value = value - - @implicit - fn __init__(out self, value: SocketENOBUFSError): - self.value = value - - @implicit - fn __init__(out self, value: SocketEPROTONOSUPPORTError): - self.value = value - - @implicit - fn __init__(out self, var value: Error): - self.value = value^ - - fn write_to[W: Writer, //](self, mut writer: W): - if self.value.isa[SocketEACCESError](): - writer.write(self.value[SocketEACCESError]) - elif self.value.isa[SocketEAFNOSUPPORTError](): - writer.write(self.value[SocketEAFNOSUPPORTError]) - elif self.value.isa[SocketEINVALError](): - writer.write(self.value[SocketEINVALError]) - elif self.value.isa[SocketEMFILEError](): - writer.write(self.value[SocketEMFILEError]) - elif self.value.isa[SocketENFILEError](): - writer.write(self.value[SocketENFILEError]) - elif self.value.isa[SocketENOBUFSError](): - writer.write(self.value[SocketENOBUFSError]) - elif self.value.isa[SocketEPROTONOSUPPORTError](): - writer.write(self.value[SocketEPROTONOSUPPORTError]) - elif self.value.isa[Error](): - writer.write(self.value[Error]) - - fn isa[T: AnyType](self) -> Bool: - return self.value.isa[T]() - - fn __getitem__[T: AnyType](self) -> ref [self.value] T: - return self.value[T] - - fn __str__(self) -> String: - return String.write(self) +comptime AcceptError = Variant[ + AcceptEBADFError, + AcceptEINTRError, + AcceptEAGAINError, + AcceptECONNABORTEDError, + AcceptEFAULTError, + AcceptEINVALError, + AcceptEMFILEError, + AcceptENFILEError, + AcceptENOBUFSError, + AcceptENOTSOCKError, + AcceptEOPNOTSUPPError, + AcceptEPERMError, + AcceptEPROTOError, + Error, +] + + +comptime BindError = Variant[ + BindEACCESError, + BindEADDRINUSEError, + BindEBADFError, + BindEFAULTError, + BindEINVALError, + BindELOOPError, + BindENAMETOOLONGError, + BindENOMEMError, + BindENOTSOCKError, + Error, +] + + +comptime CloseError = Variant[CloseEBADFError, CloseEINTRError, CloseEIOError, CloseENOSPCError] + + +comptime ConnectError = Variant[ + ConnectEACCESError, + ConnectEADDRINUSEError, + ConnectEAFNOSUPPORTError, + ConnectEAGAINError, + ConnectEALREADYError, + ConnectEBADFError, + ConnectECONNREFUSEDError, + ConnectEFAULTError, + ConnectEINPROGRESSError, + ConnectEINTRError, + ConnectEISCONNError, + ConnectENETUNREACHError, + ConnectENOTSOCKError, + ConnectETIMEDOUTError, + Error, +] + + +comptime GetpeernameError = Variant[ + GetpeernameEBADFError, + GetpeernameEFAULTError, + GetpeernameEINVALError, + GetpeernameENOBUFSError, + GetpeernameENOTCONNError, + GetpeernameENOTSOCKError, +] + + +comptime GetsocknameError = Variant[ + GetsocknameEBADFError, + GetsocknameEFAULTError, + GetsocknameEINVALError, + GetsocknameENOBUFSError, + GetsocknameENOTSOCKError, +] + + +comptime GetsockoptError = Variant[ + GetsockoptEBADFError, + GetsockoptEFAULTError, + GetsockoptEINVALError, + GetsockoptENOPROTOOPTError, + GetsockoptENOTSOCKError, + Error, +] + + +comptime ListenError = Variant[ListenEADDRINUSEError, ListenEBADFError, ListenENOTSOCKError, ListenEOPNOTSUPPError] + + +comptime RecvError = Variant[ + RecvEAGAINError, + RecvEBADFError, + RecvECONNREFUSEDError, + RecvEFAULTError, + RecvEINTRError, + RecvENOTCONNError, + RecvENOTSOCKError, + Error, +] + + +comptime RecvfromError = Variant[ + RecvfromEAGAINError, + RecvfromEBADFError, + RecvfromECONNRESETError, + RecvfromEINTRError, + RecvfromEINVALError, + RecvfromEIOError, + RecvfromENOBUFSError, + RecvfromENOMEMError, + RecvfromENOTCONNError, + RecvfromENOTSOCKError, + RecvfromEOPNOTSUPPError, + RecvfromETIMEDOUTError, + Error, +] + + +comptime SendError = Variant[ + SendEAGAINError, + SendEBADFError, + SendECONNREFUSEDError, + SendECONNRESETError, + SendEDESTADDRREQError, + SendEFAULTError, + SendEINTRError, + SendEINVALError, + SendEISCONNError, + SendENOBUFSError, + SendENOMEMError, + SendENOTCONNError, + SendENOTSOCKError, + SendEOPNOTSUPPError, + Error, +] + + +comptime SendtoError = Variant[ + SendtoEACCESError, + SendtoEAFNOSUPPORTError, + SendtoEAGAINError, + SendtoEBADFError, + SendtoECONNRESETError, + SendtoEDESTADDRREQError, + SendtoEHOSTUNREACHError, + SendtoEINTRError, + SendtoEINVALError, + SendtoEIOError, + SendtoEISCONNError, + SendtoELOOPError, + SendtoEMSGSIZEError, + SendtoENAMETOOLONGError, + SendtoENETDOWNError, + SendtoENETUNREACHError, + SendtoENOBUFSError, + SendtoENOMEMError, + SendtoENOTCONNError, + SendtoENOTSOCKError, + SendtoEPIPEError, + Error, +] + + +comptime SetsockoptError = Variant[ + SetsockoptEBADFError, + SetsockoptEFAULTError, + SetsockoptEINVALError, + SetsockoptENOPROTOOPTError, + SetsockoptENOTSOCKError, + Error, +] + + +comptime ShutdownError = Variant[ShutdownEBADFError, ShutdownEINVALError, ShutdownENOTCONNError, ShutdownENOTSOCKError] + + +comptime SocketError = Variant[ + SocketEACCESError, + SocketEAFNOSUPPORTError, + SocketEINVALError, + SocketEMFILEError, + SocketENFILEError, + SocketENOBUFSError, + SocketEPROTONOSUPPORTError, + Error, +] diff --git a/lightbug_http/socket.mojo b/lightbug_http/socket.mojo index 3dbcb812..69277abf 100644 --- a/lightbug_http/socket.mojo +++ b/lightbug_http/socket.mojo @@ -819,7 +819,7 @@ struct Socket[ """ # SO_RCVTIMEO requires a timeval struct: {tv_sec: Int64, tv_usec: Int64} # (16 bytes on both macOS and Linux 64-bit). - var timeval = InlineArray[Int64, 2](seconds, 0) + var timeval: InlineArray[Int64, 2] = [seconds, 0] _ = _setsockopt( self.fd.value, SOL_SOCKET,