POSIXError

import FoundationEssentials

protocol Equatable

A type that can be compared for value equality.

protocol Error : Sendable

A type representing an error value that can be thrown.

protocol Hashable : Equatable

A type that can be hashed into a Hasher to produce an integer hash value.

protocol Sendable

init(_ code: POSIXError.Code)

static var E2BIG: POSIXErrorCode { get }

Argument list too long.

static var EACCES: POSIXErrorCode { get }

Permission denied.

static var EADDRINUSE: POSIXErrorCode { get }

Address already in use.

static var EADDRNOTAVAIL: POSIXErrorCode { get }

Can’t assign requested address.

static var EAFNOSUPPORT: POSIXErrorCode { get }

Address family not supported by protocol family.

static var EAGAIN: POSIXErrorCode { get }

Resource temporarily unavailable.

static var EALREADY: POSIXErrorCode { get }

Operation already in progress.

static var EBADF: POSIXErrorCode { get }

Bad file descriptor.

static var EBADMSG: POSIXErrorCode { get }

Bad message.

static var EBUSY: POSIXErrorCode { get }

Device / Resource busy.

static var ECANCELED: POSIXErrorCode { get }

Operation canceled.

static var ECHILD: POSIXErrorCode { get }

No child processes.

static var ECONNABORTED: POSIXErrorCode { get }

Software caused connection abort.

static var ECONNREFUSED: POSIXErrorCode { get }

Connection refused.

static var ECONNRESET: POSIXErrorCode { get }

Connection reset by peer.

static var EDEADLK: POSIXErrorCode { get }

Resource deadlock avoided.

static var EDESTADDRREQ: POSIXErrorCode { get }

Destination address required.

static var EDOM: POSIXErrorCode { get }

Numerical argument out of domain.

static var EDQUOT: POSIXErrorCode { get }

Disk quota exceeded.

static var EEXIST: POSIXErrorCode { get }

File exists.

static var EFAULT: POSIXErrorCode { get }

Bad address.

static var EFBIG: POSIXErrorCode { get }

File too large.

static var EHOSTDOWN: POSIXErrorCode { get }

Host is down.

static var EHOSTUNREACH: POSIXErrorCode { get }

No route to host.

static var EIDRM: POSIXErrorCode { get }

Identifier removed.

static var EILSEQ: POSIXErrorCode { get }

Illegal byte sequence.

static var EINPROGRESS: POSIXErrorCode { get }

Operation now in progress.

static var EINTR: POSIXErrorCode { get }

Interrupted system call.

static var EINVAL: POSIXErrorCode { get }

Invalid argument.

static var EIO: POSIXErrorCode { get }

Input/output error.

static var EISCONN: POSIXErrorCode { get }

Socket is already connected.

static var EISDIR: POSIXErrorCode { get }

Is a directory.

static var ELOOP: POSIXErrorCode { get }

Too many levels of symbolic links.

static var EMFILE: POSIXErrorCode { get }

Too many open files.

static var EMLINK: POSIXErrorCode { get }

Too many links.

static var EMSGSIZE: POSIXErrorCode { get }

Message too long.

static var EMULTIHOP: POSIXErrorCode { get }

Reserved.

static var ENAMETOOLONG: POSIXErrorCode { get }

File name too long.

static var ENETDOWN: POSIXErrorCode { get }

Network is down.

static var ENETRESET: POSIXErrorCode { get }

Network dropped connection on reset.

static var ENETUNREACH: POSIXErrorCode { get }

Network is unreachable.

static var ENFILE: POSIXErrorCode { get }

Too many open files in system.

static var ENOBUFS: POSIXErrorCode { get }

No buffer space available.

static var ENODATA: POSIXErrorCode { get }

No message available on STREAM.

static var ENODEV: POSIXErrorCode { get }

Operation not supported by device.

static var ENOENT: POSIXErrorCode { get }

No such file or directory.

static var ENOEXEC: POSIXErrorCode { get }

Exec format error.

static var ENOLCK: POSIXErrorCode { get }

No locks available.

static var ENOLINK: POSIXErrorCode { get }

Reserved.

static var ENOMEM: POSIXErrorCode { get }

Cannot allocate memory.

static var ENOMSG: POSIXErrorCode { get }

No message of desired type.

static var ENOPROTOOPT: POSIXErrorCode { get }

Protocol not available.

static var ENOSPC: POSIXErrorCode { get }

No space left on device.

static var ENOSR: POSIXErrorCode { get }

No STREAM resources.

static var ENOSTR: POSIXErrorCode { get }

Not a STREAM.

static var ENOSYS: POSIXErrorCode { get }

Function not implemented.

static var ENOTBLK: POSIXErrorCode { get }

Block device required.

static var ENOTCONN: POSIXErrorCode { get }

Socket is not connected.

static var ENOTDIR: POSIXErrorCode { get }

Not a directory.

static var ENOTEMPTY: POSIXErrorCode { get }

Directory not empty.

static var ENOTRECOVERABLE: POSIXErrorCode { get }

State not recoverable.

static var ENOTSOCK: POSIXErrorCode { get }

Socket operation on non-socket.

static var ENOTTY: POSIXErrorCode { get }

Inappropriate ioctl for device.

static var ENXIO: POSIXErrorCode { get }

Device not configured.

static var EOVERFLOW: POSIXErrorCode { get }

Value too large to be stored in data type.

static var EOWNERDEAD: POSIXErrorCode { get }

Previous owner died.

static var EPERM: POSIXErrorCode { get }

Operation not permitted.

static var EPFNOSUPPORT: POSIXErrorCode { get }

Protocol family not supported.

static var EPIPE: POSIXErrorCode { get }

Broken pipe.

static var EPROTO: POSIXErrorCode { get }

Protocol error.

static var EPROTONOSUPPORT: POSIXErrorCode { get }

Protocol not supported.

static var EPROTOTYPE: POSIXErrorCode { get }

Protocol wrong type for socket.

static var ERANGE: POSIXErrorCode { get }

Result too large.

static var EREMOTE: POSIXErrorCode { get }

Too many levels of remote in path.

static var EROFS: POSIXErrorCode { get }

Read-only file system.

static var ESHUTDOWN: POSIXErrorCode { get }

Can’t send after socket shutdown.

static var ESOCKTNOSUPPORT: POSIXErrorCode { get }

Socket type not supported.

static var ESPIPE: POSIXErrorCode { get }

Illegal seek.

static var ESRCH: POSIXErrorCode { get }

No such process.

static var ESTALE: POSIXErrorCode { get }

Stale NFS file handle.

static var ETIME: POSIXErrorCode { get }

STREAM ioctl timeout.

static var ETIMEDOUT: POSIXErrorCode { get }

Operation timed out.

static var ETOOMANYREFS: POSIXErrorCode { get }

Too many references: can’t splice.

static var ETXTBSY: POSIXErrorCode { get }

Text file busy.

static var EUSERS: POSIXErrorCode { get }

Too many users.

static var EWOULDBLOCK: POSIXErrorCode { get }

Operation would block.

static var EXDEV: POSIXErrorCode { get }

Cross-device link.

static var errorDomain: String { get }

let code: POSIXError.Code

func hash(into hasher: inout Hasher)

typealias Code = POSIXErrorCode

static func != (lhs: Self, rhs: Self) -> Bool

Returns a Boolean value indicating whether two values are not equal.

import Foundation

protocol Copyable

A type whose values can be implicitly or explicitly copied.

protocol CustomNSError : Error

Describes an error type that specifically provides a domain, code, and user-info dictionary.

protocol CustomStringConvertible

A type with a customized textual representation.

protocol Escapable

typealias Code = POSIXErrorCode

static var errorDomain: String { get }

Default domain of the error.

var localizedDescription: String { get }

Retrieve the localized description for this error.