Sentinel handle representing the current/present working directory.

If the package is fully supported on the current target. If it is not it will compile but work in a matter where things are unimplemented. Additionally if it is `FULLY_SUPPORTED` it may still return `.Unsupported` in `acquire_thread_event_loop` If the target does not support the needed syscalls for operating the package.

The maximum size of user arguments for an operation, can be increased at the cost of more RAM.

Read, write, and execute permissions for user, group, and others.

Default permissions used when creating a directory (read, write, and execute for everyone).

Default permissions used when creating a file (read and write for everyone).

Convenience permission sets.

Read and write permissions for user, group, and others.

The maximum size of user arguments for an operation, can be increased at the cost of more RAM.

A union of closable types that can be passed to `close`.

An event loop, one per thread, consider the fields private. Do not copy.

Errors gotten from file system operations.

Errors regarding general usage of the event loop.

File permission bit-set. This type represents POSIX-style file permissions, split into user, group, and other categories, each with read, write, and execute flags.

Using the given socket, accepts the next incoming connection, calling the callback when that happens. Any user data can be set on the returned operation's `user_data` field. Polymorphic variants for type safe user data are available under `accept_poly`, `accept_poly2`, and `accept_poly3`. Inputs: - socket: A bound and listening socket *associated with the event loop* - cb: The callback to be called when the operation finishes, `Operation.accept` will contain results - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Using the given socket, accepts the next incoming connection, calling the callback when that happens. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - socket: A bound and listening socket *associated with the event loop* - p: User data, the callback will receive this as it's second argument - cb: The callback to be called when the operation finishes, `Operation.accept` will contain results - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Using the given socket, accepts the next incoming connection, calling the callback when that happens. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - socket: A bound and listening socket *associated with the event loop* - p: User data, the callback will receive this as it's second argument - p2: User data, the callback will receive this as it's third argument - cb: The callback to be called when the operation finishes, `Operation.accept` will contain results - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Using the given socket, accepts the next incoming connection, calling the callback when that happens. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - socket: A bound and listening socket *associated with the event loop* - p: User data, the callback will receive this as it's second argument - p2: User data, the callback will receive this as it's third argument - p3: User data, the callback will receive this as it's fourth argument - cb: The callback to be called when the operation finishes, `Operation.accept` will contain results - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Initialize or increment the reference counted event loop for the current thread.

Associate the given OS handle, not opened through this package, with the event loop. Consider using this package's `open` or `open_sync` directly instead. The handle returned is for convenience, it is actually still the same handle as given. Thus you should not close the given handle. On Windows, this can error when a file is not opened with the `FILE_FLAG_OVERLAPPED` flag. If using `core:os`, that is set when you specify the `O_NONBLOCK` flag. There is no way to add that after the fact.

Associate the given socket, not created through this package, with the event loop. Consider using this package's `create_socket` directly instead.

Closes the given subject (file or socket). Closing something that has IO in progress may or may not cancel it, and may or may not call the callback. For consistent behavior first call `remove` on in progress IO. Any user data can be set on the returned operation's `user_data` field. Polymorphic variants for type safe user data are available under `close_poly`, `close_poly2`, and `close_poly3`. Inputs: - subject: The subject (socket or file) to close - cb: The optional callback to be called when the operation finishes, `Operation.close` will contain results - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Closes the given subject (file or socket). Closing something that has IO in progress may or may not cancel it, and may or may not call the callback. For consistent behavior first call `remove` on in progress IO. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - subject: The subject (socket or file) to close - p: User data, the callback will receive this as it's second argument - cb: The optional callback to be called when the operation finishes, `Operation.close` will contain results - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Closes the given subject (file or socket). Closing something that has IO in progress may or may not cancel it, and may or may not call the callback. For consistent behavior first call `remove` on in progress IO. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - subject: The subject (socket or file) to close - p: User data, the callback will receive this as it's second argument - p2: User data, the callback will receive this as it's third argument - cb: The optional callback to be called when the operation finishes, `Operation.close` will contain results - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Closes the given subject (file or socket). Closing something that has IO in progress may or may not cancel it, and may or may not call the callback. For consistent behavior first call `remove` on in progress IO. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - subject: The subject (socket or file) to close - p: User data, the callback will receive this as it's second argument - p2: User data, the callback will receive this as it's third argument - p3: User data, the callback will receive this as it's fourth argument - cb: The optional callback to be called when the operation finishes, `Operation.close` will contain results - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Creates a socket for use in `nbio` and relates it to the given event loop. Inputs: - family: Should this be an IP4 or IP6 socket - protocol: The type of socket (TCP or UDP) - l: The event loop to associate it with, defaults to the current thread's loop Returns: - socket: The created socket, consider `create_{udp|tcp}_socket` for a typed socket instead of the union - err: A network error (`Create_Socket_Error`, or `Set_Blocking_Error`) which happened while opening

Creates a TCP socket for use in `nbio` and relates it to the given event loop. Inputs: - family: Should this be an IP4 or IP6 socket - l: The event loop to associate it with, defaults to the current thread's loop Returns: - socket: The created TCP socket - err: A network error (`Create_Socket_Error`, or `Set_Blocking_Error`) which happened while opening

Creates a UDP socket for use in `nbio` and relates it to the given event loop. Inputs: - family: Should this be an IP4 or IP6 socket - l: The event loop to associate it with, defaults to the current thread's loop Returns: - socket: The created UDP socket - err: A network error (`Create_Socket_Error`, or `Set_Blocking_Error`) which happened while opening

Detach an operation from the package's lifetime management. By default the operation's lifetime is managed by the package and freed after a callback is called. Calling this function detaches the operation from this lifetime. You are expected to call `reattach` to give the package back this operation.

Dials the given endpoint. Any user data can be set on the returned operation's `user_data` field. Polymorphic variants for type safe user data are available under `dial_poly`, `dial_poly2`, and `dial_poly3`. Inputs: - endpoint: The endpoint to connect to - cb: The callback to be called when the operation finishes, `Operation.dial` will contain results - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Dials the given endpoint. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - endpoint: The endpoint to connect to - p: User data, the callback will receive this as it's second argument - cb: The callback to be called when the operation finishes, `Operation.dial` will contain results - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Dials the given endpoint. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - endpoint: The endpoint to connect to - p: User data, the callback will receive this as it's second argument - p2: User data, the callback will receive this as it's third argument - cb: The callback to be called when the operation finishes, `Operation.dial` will contain results - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Dials the given endpoint. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - endpoint: The endpoint to connect to - p: User data, the callback will receive this as it's second argument - p2: User data, the callback will receive this as it's third argument - p3: User data, the callback will receive this as it's fourth argument - cb: The callback to be called when the operation finishes, `Operation.dial` will contain results - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Execute an operation. If the operation is attached to another thread's event loop, it is queued to be executed on that event loop, optionally waking that loop up (from a blocking `tick`) with `trigger_wake_up`.

Creates a socket, sets non blocking mode, relates it to the given IO, binds the socket to the given endpoint and starts listening. Inputs: - endpoint: Where to bind the socket to - backlog: The maximum length to which the queue of pending connections may grow, before refusing connections - l: The event loop to associate the socket with, defaults to the current thread's loop Returns: - socket: The opened, bound and listening socket - err: A network error (`Create_Socket_Error`, `Bind_Error`, or `Listen_Error`) that has happened

Schedules an operation that completes on the next event loop tick. This is equivalent to `timeout(0, ...)`.

Schedules an operation that completes on the next event loop tick. This is equivalent to `timeout_poly(0, ...)`.

Schedules an operation that completes on the next event loop tick. This is equivalent to `timeout_poly2(0, ...)`.

Schedules an operation that completes on the next event loop tick. This is equivalent to `timeout_poly3(0, ...)`.

Returns the current time (cached at most at the beginning of the current tick).

Returns the number of in-progress operations to be completed on the event loop.

Opens a file and associates it with the event loop. Any user data can be set on the returned operation's `user_data` field. Polymorphic variants for type safe user data are available under `open_poly`, `open_poly2`, and `open_poly3`. Inputs: - path: Path to the file, if not absolute: relative from `dir` - cb: The callback to be called when the operation finishes, `Operation.open` will contain results - mode: File open mode flags, defaults to read-only - perm: Permissions to use when creating a file, defaults to read+write for everybody - dir: Directory that `path` is relative from (if it is relative), defaults to the current working directory - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Opens a file and associates it with the event loop. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - path: Path to the file, if not absolute: relative from `dir` - p: User data, the callback will receive this as its second argument - cb: The callback to be called when the operation finishes, `Operation.open` will contain results - mode: File open mode flags, defaults to read-only - perm: Permissions to use when creating a file, defaults to read+write for everybody - dir: Directory that `path` is relative from (if it is relative), defaults to the current working directory - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Opens a file and associates it with the event loop. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - path: Path to the file, if not absolute: relative from `dir` - p: User data, the callback will receive this as its second argument - p2: User data, the callback will receive this as its third argument - cb: The callback to be called when the operation finishes, `Operation.open` will contain results - mode: File open mode flags, defaults to read-only - perm: Permissions to use when creating a file, defaults to read+write for everybody - dir: Directory that `path` is relative from (if it is relative), defaults to the current working directory - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Asynchronously opens a file and associates it with the event loop. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - path: Path to the file, if not absolute: relative from `dir` - p: User data, the callback will receive this as its second argument - p2: User data, the callback will receive this as its third argument - p3: User data, the callback will receive this as its fourth argument - cb: The callback to be called when the operation finishes, `Operation.open` will contain results - mode: File open mode flags, defaults to read-only - perm: Permissions to use when creating a file, defaults to read+write for everybody - dir: Directory that `path` is relative from (if it is relative), defaults to the current working directory - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Opens a file and associates it with the event loop. Inputs: - path: path to the file, if not absolute: relative from `dir` - dir: directory that `path` is relative from (if it is relative), defaults to the current working directory - mode: open mode, defaults to read-only - perm: permissions to use when creating a file, defaults to read+write for everybody - l: event loop to associate the file with, defaults to the current thread's Returns: - handle: The file handle - err: An error if it occurred

Poll a socket for readiness. NOTE: this is provided to help with "legacy" APIs that require polling behavior. If you can avoid it and use the other procs in this package, do so. Any user data can be set on the returned operation's `user_data` field. Polymorphic variants for type safe user data are available under `poll_poly`, `poll_poly2`, and `poll_poly3`. Inputs: - socket: Socket to poll that is *associated with the event loop* - event: Event to poll for - cb: The callback to be called when the operation finishes, `Operation.poll` will contain results - timeout: Optional timeout for the operation, the callback will receive a `.Timeout` result after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Poll a socket for readiness. NOTE: this is provided to help with "legacy" APIs that require polling behavior. If you can avoid it and use the other procs in this package, do so. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - socket: Socket to poll that is *associated with the event loop* - event: Event to poll for - p: User data, the callback will receive this as its second argument - cb: The callback to be called when the operation finishes, `Operation.poll` will contain results - timeout: Optional timeout for the operation, the callback will receive a `.Timeout` result after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Poll a socket for readiness. NOTE: this is provided to help with "legacy" APIs that require polling behavior. If you can avoid it and use the other procs in this package, do so. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - socket: Socket to poll that is *associated with the event loop* - event: Event to poll for - p: User data, the callback will receive this as its second argument - p2: User data, the callback will receive this as its third argument - cb: The callback to be called when the operation finishes, `Operation.poll` will contain results - timeout: Optional timeout for the operation, the callback will receive a `.Timeout` result after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Poll a socket for readiness. NOTE: this is provided to help with "legacy" APIs that require polling behavior. If you can avoid it and use the other procs in this package, do so. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - socket: Socket to poll that is *associated with the event loop* - event: Event to poll for - p: User data, the callback will receive this as its second argument - p2: User data, the callback will receive this as its third argument - p3: User data, the callback will receive this as its fourth argument - cb: The callback to be called when the operation finishes, `Operation.poll` will contain results - timeout: Optional timeout for the operation, the callback will receive a `.Timeout` result after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Retrieves and preps an operation to do an accept without executing it. Executing can then be done with the `exec` procedure. The timeout is calculated from the time when this procedure was called, not from when it's executed. Any user data can be set on the returned operation's `user_data` field. Inputs: - socket: A bound and listening socket *associated with the event loop* - cb: The callback to be called when the operation finishes, `Operation.accept` will contain results - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Retrieves and preps an operation to do a close without executing it. Executing can then be done with the `exec` procedure. Closing something that has IO in progress may or may not cancel it, and may or may not call the callback. For consistent behavior first call `remove` on in progress IO. Any user data can be set on the returned operation's `user_data` field. Inputs: - subject: The subject (socket or file) to close - cb: The optional callback to be called when the operation finishes, `Operation.close` will contain results - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Retrieves and preps an operation to do a dial operation without executing it. Executing can then be done with the `exec` procedure. The timeout is calculated from the time when this procedure was called, not from when it's executed. Any user data can be set on the returned operation's `user_data` field. Inputs: - endpoint: The endpoint to connect to - cb: The callback to be called when the operation finishes, `Operation.dial` will contain results - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Retrieves and preps an operation that completes on the next event loop tick. This is equivalent to `prep_timeout(0, ...)`.

Retrieves and preps an operation to open a file without executing it. Executing can then be done with the `exec` procedure. Any user data can be set on the returned operation's `user_data` field. Inputs: - path: Path to the file, if not absolute: relative from `dir` - cb: The callback to be called when the operation finishes, `Operation.open` will contain results - mode: File open mode flags, defaults to read-only - perm: Permissions to use when creating a file, defaults to read+write for everybody - dir: Directory that `path` is relative from (if it is relative), defaults to the current working directory - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Retrieves and preps an operation to poll a socket without executing it. Executing can then be done with the `exec` procedure. The timeout is calculated from the time when this procedure was called, not from when it's executed. Any user data can be set on the returned operation's `user_data` field. Inputs: - socket: Socket to poll that is *associated with the event loop* - event: Event to poll for - cb: The callback to be called when the operation finishes, `Operation.poll` will contain results - timeout: Optional timeout for the operation, the callback will receive a `.Timeout` result after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Retrieves and preps a positional read operation without executing it. This is a pread-style operation: the read starts at the given offset and does not modify the handle's current file position. Executing can then be done with the `exec` procedure. The timeout is calculated from the time when this procedure was called, not from when it's executed. Any user data can be set on the returned operation's `user_data` field. Inputs: - handle: Handle to read from - offset: Offset to read from - buf: Buffer to read data into (must not be empty) - cb: The callback to be called when the operation finishes, `Operation.read` will contain results - all: Whether to read until the buffer is full or an error occurs - timeout: Optional timeout for the operation - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Retrieves and preps an operation to do a receive without executing it. Executing can then be done with the `exec` procedure. To avoid ambiguity between a closed connection and a 0-byte read, the provided buffers must have a total capacity greater than 0. The `bufs` slice itself is copied into the operation, so it can be temporary (e.g. on the stack), but the underlying memory of the buffers must remain valid until the callback is fired. The timeout is calculated from the time when this procedure was called, not from when it's executed. Any user data can be set on the returned operation's `user_data` field. Inputs: - socket: The socket to receive from - bufs: Buffers to fill with received data - cb: The callback to be called when the operation finishes, `Operation.recv` will contain results - all: If true, waits until all buffers are full before completing (TCP only, ignored for UDP) - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Retrieves and preps an operation to do a send without executing it. Executing can then be done with the `exec` procedure. The `bufs` slice itself is copied into the operation, so it can be temporary (e.g. on the stack), but the underlying memory of the buffers must remain valid until the callback is fired. The timeout is calculated from the time when this procedure was called, not from when it's executed. Any user data can be set on the returned operation's `user_data` field. Inputs: - socket: The socket to send to - bufs: Buffers containing the data to send - cb: The callback to be called when the operation finishes, `Operation.send` will contain results - endpoint: The destination endpoint (UDP only, ignored for TCP) - all: If true, the operation ensures all data is sent before completing - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Retrieves and preps an operation to send a file over a socket without executing it. Executing can then be done with the `exec` procedure. This uses high-performance zero-copy system calls where available. Note: This is emulated on NetBSD and OpenBSD (stat -> mmap -> send) as they lack a native sendfile implementation. Any user data can be set on the returned operation's `user_data` field. Inputs: - socket: The destination TCP socket - file: The source file handle - cb: The callback to be called when data is sent (if `progress_updates` is true) or the operation completes - offset: Byte offset to start reading from the file - nbytes: Total bytes to send (use SEND_ENTIRE_FILE for the whole file) - progress_updates: If true, the callback fires multiple times to report progress, `sent == nbytes` means te operation completed - timeout: Optional timeout for the operation - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the final callback is called

Retrieves and preps an operation to stat a handle without executing it. Executing can then be done with the `exec` procedure. Any user data can be set on the returned operation's `user_data` field. Inputs: - handle: Handle to retrieve stat - cb: The callback to be called when the operation finishes, `Operation.stat` will contain results - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Retrieves and preps a timeout operation without executing it. Executing can then be done with the `exec` procedure. Any user data can be set on the returned operation's `user_data` field. Inputs: - duration: Duration to wait before the operation completes - cb: The callback to be called when the operation finishes - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Retrieves and preps a positional write operation without executing it. This is a pwrite-style operation: the write starts at the given offset and does not modify the handle's current file position. Executing can then be done with the `exec` procedure. The timeout is calculated from the time when this procedure was called, not from when it's executed. Any user data can be set on the returned operation's `user_data` field. Inputs: - handle: Handle to write to - offset: Offset to write to - buf: Buffer containing data to write (must not be empty) - cb: The callback to be called when the operation finishes, `Operation.write` will contain results - all: Whether to write until the entire buffer is written or an error occurs - timeout: Optional timeout for the operation - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Reads data from a handle at a specific offset. This is a pread-style operation: the read starts at the given offset and does not modify the handle's current file position. Any user data can be set on the returned operation's `user_data` field. Polymorphic variants for type safe user data are available under `read_poly`, `read_poly2`, and `read_poly3`. Inputs: - handle: Handle to read from - offset: Offset to read from - buf: Buffer to read data into (must not be empty) - cb: The callback to be called when the operation finishes, `Operation.read` will contain results - all: Whether to read until the buffer is full or an error occurs - timeout: Optional timeout for the operation - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Combines multiple operations (open, stat, read, close) into one that reads an entire regular file. The error contains the `operation` that the error happened on. Inputs: - path: path to the file, if not absolute: relative from `dir` - user_data: a pointer passed through into the callback - cb: the callback to call once completed, called with the user data, file data, and an optional error - allocator: the allocator to allocate the file's contents onto - dir: directory that `path` is relative from (if it is relative), defaults to the current working directory - l: event loop to execute the operation on

Reads data from a handle at a specific offset. This is a pread-style operation: the read starts at the given offset and does not modify the handle's current file position. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - handle: Handle to read from - offset: Offset to read from - buf: Buffer to read data into (must not be empty) - p: User data, the callback will receive this as its second argument - cb: The callback to be called when the operation finishes, `Operation.read` will contain results - all: Whether to read until the buffer is full or an error occurs - timeout: Optional timeout for the operation - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Reads data from a handle at a specific offset. This is a pread-style operation: the read starts at the given offset and does not modify the handle's current file position. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - handle: Handle to read from - offset: Offset to read from - buf: Buffer to read data into (must not be empty) - p: User data, the callback will receive this as its second argument - p2: User data, the callback will receive this as its third argument - cb: The callback to be called when the operation finishes, `Operation.read` will contain results - all: Whether to read until the buffer is full or an error occurs - timeout: Optional timeout for the operation - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Reads data from a handle at a specific offset. This is a pread-style operation: the read starts at the given offset and does not modify the handle's current file position. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - handle: Handle to read from - offset: Offset to read from - buf: Buffer to read data into (must not be empty) - p: User data, the callback will receive this as its second argument - p2: User data, the callback will receive this as its third argument - p3: User data, the callback will receive this as its fourth argument - cb: The callback to be called when the operation finishes, `Operation.read` will contain results - all: Whether to read until the buffer is full or an error occurs - timeout: Optional timeout for the operation - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Reattach an operation to the package's lifetime management.

Receives data from the socket. If the operation completes with 0 bytes received and no error, it indicates the connection was closed by the peer. The `bufs` slice itself is copied into the operation, so it can be temporary (e.g. on the stack), but the underlying memory of the buffers must remain valid until the callback is fired. Any user data can be set on the returned operation's `user_data` field. Polymorphic variants for type safe user data are available under `recv_poly`, `recv_poly2`, and `recv_poly3`. Inputs: - socket: The socket to receive from - bufs: Buffers to fill with received data - cb: The callback to be called when the operation finishes, `Operation.recv` will contain results - all: If true, waits until all buffers are full before completing (TCP only, ignored for UDP) - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Receives data from the socket. If the operation completes with 0 bytes received and no error, it indicates the connection was closed by the peer. The `bufs` slice itself is copied into the operation, so it can be temporary (e.g. on the stack), but the underlying memory of the buffers must remain valid until the callback is fired. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - socket: The socket to receive from - bufs: Buffers to fill with received data - p: User data, the callback will receive this as it's second argument - cb: The callback to be called when the operation finishes, `Operation.recv` will contain results - all: If true, waits until all buffers are full before completing (TCP only, ignored for UDP) - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Receives data from the socket. If the operation completes with 0 bytes received and no error, it indicates the connection was closed by the peer. The `bufs` slice itself is copied into the operation, so it can be temporary (e.g. on the stack), but the underlying memory of the buffers must remain valid until the callback is fired. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - socket: The socket to receive from - bufs: Buffers to fill with received data - p: User data, the callback will receive this as it's second argument - p2: User data, the callback will receive this as it's third argument - cb: The callback to be called when the operation finishes, `Operation.recv` will contain results - all: If true, waits until all buffers are full before completing (TCP only, ignored for UDP) - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Receives data from the socket. If the operation completes with 0 bytes received and no error, it indicates the connection was closed by the peer. The `bufs` slice itself is copied into the operation, so it can be temporary (e.g. on the stack), but the underlying memory of the buffers must remain valid until the callback is fired. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - socket: The socket to receive from - bufs: Buffers to fill with received data - p: User data, the callback will receive this as it's second argument - p2: User data, the callback will receive this as it's third argument - p3: User data, the callback will receive this as it's fourth argument - cb: The callback to be called when the operation finishes, `Operation.recv` will contain results - all: If true, waits until all buffers are full before completing (TCP only, ignored for UDP) - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Destroy or decrease the reference counted event loop for the current thread.

Remove the given operation from the event loop. The callback of it won't be called and resources are freed. Calling `remove`: - Cancels the operation if it has not yet completed - Prevents the callback from being called Cancellation via `remove` is *final* and silent: - The callback will never be invoked - No error is delivered - The operation must be considered dead after removal WARN: the operation could have already been (partially or completely) completed. A send with `all` set to true could have sent a portion already. But also, a send that could be completed without blocking could have been completed. You just won't get a callback. WARN: once an operation's callback is called it can not be removed anymore (use after free). WARN: needs to be called from the thread of the event loop the target belongs to. Common use would be to cancel a timeout, remove a polling, or remove an `accept` before calling `close` on it's socket.

Runs the event loop by ticking in a loop until there is no more work to be done.

Runs the event loop by ticking in a loop until there is no more work to be done, or the flag `done` is `true`.

Sends data to the socket. The `bufs` slice itself is copied into the operation, so it can be temporary (e.g. on the stack), but the underlying memory of the buffers must remain valid until the callback is fired. Any user data can be set on the returned operation's `user_data` field. Polymorphic variants for type safe user data are available under `send_poly`, `send_poly2`, and `send_poly3`. Inputs: - socket: The socket to send to - bufs: Buffers containing the data to send - cb: The callback to be called when the operation finishes, `Operation.send` will contain results - endpoint: The destination endpoint (UDP only, ignored for TCP) - all: If true, the operation ensures all data is sent before completing - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Sends data to the socket. The `bufs` slice itself is copied into the operation, so it can be temporary (e.g. on the stack), but the underlying memory of the buffers must remain valid until the callback is fired. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - socket: The socket to send to - bufs: Buffers containing the data to send - p: User data, the callback will receive this as it's second argument - cb: The callback to be called when the operation finishes, `Operation.send` will contain results - endpoint: The destination endpoint (UDP only, ignored for TCP) - all: If true, the operation ensures all data is sent before completing - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Sends data to the socket. The `bufs` slice itself is copied into the operation, so it can be temporary (e.g. on the stack), but the underlying memory of the buffers must remain valid until the callback is fired. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - socket: The socket to send to - bufs: Buffers containing the data to send - p: User data, the callback will receive this as it's second argument - p2: User data, the callback will receive this as it's third argument - cb: The callback to be called when the operation finishes, `Operation.send` will contain results - endpoint: The destination endpoint (UDP only, ignored for TCP) - all: If true, the operation ensures all data is sent before completing - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Sends data to the socket. The `bufs` slice itself is copied into the operation, so it can be temporary (e.g. on the stack), but the underlying memory of the buffers must remain valid until the callback is fired. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - socket: The socket to send to - bufs: Buffers containing the data to send - p: User data, the callback will receive this as it's second argument - p2: User data, the callback will receive this as it's third argument - p3: User data, the callback will receive this as it's fourth argument - cb: The callback to be called when the operation finishes, `Operation.send` will contain results - endpoint: The destination endpoint (UDP only, ignored for TCP) - all: If true, the operation ensures all data is sent before completing - timeout: Optional timeout for the operation, the callback will get a `.Timeout` error after that duration - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Sends a file over a TCP socket. This uses high-performance zero-copy system calls where available. Note: This is emulated on NetBSD and OpenBSD (stat -> mmap -> send) as they lack a native sendfile implementation. Any user data can be set on the returned operation's `user_data` field. Polymorphic variants for type safe user data are available under `sendfile_poly`, `sendfile_poly2`, and `sendfile_poly3`. Inputs: - socket: The destination TCP socket - file: The source file handle - cb: The callback to be called when data is sent (if `progress_updates` is true) or the operation completes - offset: Byte offset to start reading from the file - nbytes: Total bytes to send (use SEND_ENTIRE_FILE for the whole file) - progress_updates: If true, the callback fires multiple times to report progress, `sent == nbytes` means te operation completed - timeout: Optional timeout for the operation - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the final callback is called

Sends a file over a TCP socket. This uses high-performance zero-copy system calls where available. Note: This is emulated on NetBSD and OpenBSD (stat -> mmap -> send) as they lack a native sendfile implementation. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - socket: The destination TCP socket - file: The source file handle - p: User data, the callback will receive this as it's second argument - cb: The callback to be called when data is sent (if `progress_updates` is true) or the operation completes - offset: Byte offset to start reading from the file - nbytes: Total bytes to send (use SEND_ENTIRE_FILE for the whole file) - progress_updates: If true, the callback fires multiple times to report progress, `sent == nbytes` means te operation completed - timeout: Optional timeout for the operation - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the final callback is called

Sends a file over a TCP socket. This uses high-performance zero-copy system calls where available. Note: This is emulated on NetBSD and OpenBSD (stat -> mmap -> send) as they lack a native sendfile implementation. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - socket: The destination TCP socket - file: The source file handle - p: User data, the callback will receive this as it's second argument - p2: User data, the callback will receive this as it's third argument - cb: The callback to be called when data is sent (if `progress_updates` is true) or the operation completes - offset: Byte offset to start reading from the file - nbytes: Total bytes to send (use SEND_ENTIRE_FILE for the whole file) - progress_updates: If true, the callback fires multiple times to report progress, `sent == nbytes` means te operation completed - timeout: Optional timeout for the operation - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the final callback is called

Sends a file over a TCP socket. This uses high-performance zero-copy system calls where available. Note: This is emulated on NetBSD and OpenBSD (stat -> mmap -> send) as they lack a native sendfile implementation. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - socket: The destination TCP socket - file: The source file handle - p: User data, the callback will receive this as it's second argument - p2: User data, the callback will receive this as it's third argument - p3: User data, the callback will receive this as it's fourth argument - cb: The callback to be called when data is sent (if `progress_updates` is true) or the operation completes - offset: Byte offset to start reading from the file - nbytes: Total bytes to send (use SEND_ENTIRE_FILE for the whole file) - progress_updates: If true, the callback fires multiple times to report progress, `sent == nbytes` means te operation completed - timeout: Optional timeout for the operation - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the final callback is called

Stats a handle. Any user data can be set on the returned operation's `user_data` field. Polymorphic variants for type safe user data are available under `stat_poly`, `stat_poly2`, and `stat_poly3`. Inputs: - handle: Handle to retrieve status information for - cb: The callback to be called when the operation finishes, `Operation.stat` will contain results - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Stats a handle. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - handle: Handle to retrieve status information for - p: User data, the callback will receive this as its second argument - cb: The callback to be called when the operation finishes, `Operation.stat` will contain results - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Stats a handle. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - handle: Handle to retrieve status information for - p: User data, the callback will receive this as its second argument - p2: User data, the callback will receive this as its third argument - cb: The callback to be called when the operation finishes, `Operation.stat` will contain results - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Stats a handle. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - handle: Handle to retrieve status information for - p: User data, the callback will receive this as its second argument - p2: User data, the callback will receive this as its third argument - p3: User data, the callback will receive this as its fourth argument - cb: The callback to be called when the operation finishes, `Operation.stat` will contain results - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Each time you call this the implementation checks its state and calls any callbacks which are ready. You would typically call this in a loop. Blocks for up-to timeout waiting for events if there is nothing to do.

Schedules a timeout that completes after the given duration. Any user data can be set on the returned operation's `user_data` field. Polymorphic variants for type safe user data are available under `timeout_poly`, `timeout_poly2`, and `timeout_poly3`. Inputs: - duration: Duration to wait before the operation completes - cb: The callback to be called when the operation finishes - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Schedules a timeout that completes after the given duration. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - dur: Duration to wait before the operation completes - p: User data, the callback will receive this as its second argument - cb: The callback to be called when the operation finishes - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Schedules a timeout that completes after the given duration. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - dur: Duration to wait before the operation completes - p: User data, the callback will receive this as its second argument - p2: User data, the callback will receive this as its third argument - cb: The callback to be called when the operation finishes - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Schedules a timeout that completes after the given duration. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - dur: Duration to wait before the operation completes - p: User data, the callback will receive this as its second argument - p2: User data, the callback will receive this as its third argument - p3: User data, the callback will receive this as its fourth argument - cb: The callback to be called when the operation finishes - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Wake up an event loop on another thread which may be blocking for completed operations. Commonly used with `exec` from a worker thread to have the event loop pick up that work. Note that by default `exec` already calls this procedure.

Writes data to a handle at a specific offset. This is a pwrite-style operation: the write starts at the given offset and does not modify the handle's current file position. Any user data can be set on the returned operation's `user_data` field. Polymorphic variants for type safe user data are available under `write_poly`, `write_poly2`, and `write_poly3`. Inputs: - handle: Handle to write to - offset: Offset to write to - buf: Buffer containing data to write (must not be empty) - cb: The callback to be called when the operation finishes, `Operation.write` will contain results - all: Whether to write until the entire buffer is written or an error occurs - timeout: Optional timeout for the operation - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Writes data to a handle at a specific offset. This is a pwrite-style operation: the write starts at the given offset and does not modify the handle's current file position. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - handle: Handle to write to - offset: Offset to write to - buf: Buffer containing data to write (must not be empty) - p: User data, the callback will receive this as its second argument - cb: The callback to be called when the operation finishes, `Operation.write` will contain results - all: Whether to write until the entire buffer is written or an error occurs - timeout: Optional timeout for the operation - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Writes data to a handle at a specific offset. This is a pwrite-style operation: the write starts at the given offset and does not modify the handle's current file position. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - handle: Handle to write to - offset: Offset to write to - buf: Buffer containing data to write (must not be empty) - p: User data, the callback will receive this as its second argument - p2: User data, the callback will receive this as its third argument - cb: The callback to be called when the operation finishes, `Operation.write` will contain results - all: Whether to write until the entire buffer is written or an error occurs - timeout: Optional timeout for the operation - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called

Writes data to a handle at a specific offset. This is a pwrite-style operation: the write starts at the given offset and does not modify the handle's current file position. This procedure uses polymorphism for type safe user data up to a certain size. Inputs: - handle: Handle to write to - offset: Offset to write to - buf: Buffer containing data to write (must not be empty) - p: User data, the callback will receive this as its second argument - p2: User data, the callback will receive this as its third argument - p3: User data, the callback will receive this as its fourth argument - cb: The callback to be called when the operation finishes, `Operation.write` will contain results - all: Whether to write until the entire buffer is written or an error occurs - timeout: Optional timeout for the operation - l: Event loop to associate the operation with, defaults to the current thread's loop Returns: A non-nil pointer to the operation, alive until the callback is called