The cl-async Reference Manual

4.1.1 cl-async/cl-async.asd

Source

cl-async.asd.

Parent Component

cl-async (system).

ASDF Systems

• cl-async.
• cl-async-base.
• cl-async-util.

---

4.1.2 cl-async/src/package.lisp

Source

cl-async.asd.

Parent Component

src (module).

Packages

cl-async.

---

4.1.3 cl-async/src/event-loop.lisp

Dependency

package.lisp (file).

Source

cl-async.asd.

Parent Component

src (module).

Public Interface

• add-event-loop-exit-callback (function).
• dump-event-loop-status (function).
• exit-event-loop (function).
• ref (generic function).
• start-event-loop (function).
• stats (function).
• unref (generic function).
• with-event-loop (macro).

Internals

• *event-base-registry* (special variable).
• *event-base-registry-lock* (special variable).
• *loop-close-iters* (special variable).
• check-event-loop-running (function).
• do-close-loop (function).
• handle-cleanup (generic function).
• loop-exit-walk-cb (function).
• process-event-loop-exit-callbacks (function).
• walk-cb (function).

---

4.1.4 cl-async/src/event.lisp

Dependencies

• package.lisp (file).
• event-loop.lisp (file).

Source

cl-async.asd.

Parent Component

src (module).

Public Interface

• add-event (function).
• delay (function).
• event (class).
• event-c (reader method).
• (setf event-c) (writer method).
• event-freed (reader method).
• (setf event-freed) (writer method).
• event-freed (condition).
• event-freed-p (reader method).
• free-event (function).
• interval (function).
• make-event (function).
• ref (method).
• remove-event (function).
• remove-interval (function).
• unref (method).
• with-delay (macro).
• with-interval (macro).

Internals

• check-event-unfreed (function).
• event-freed-event (reader method).
• (setf event-freed-event) (writer method).
• handle-cleanup (method).
• timer-cb (function).
• timer-close-cb (function).

---

4.1.5 cl-async/src/dns.lisp

Dependencies

• package.lisp (file).
• event.lisp (file).

Source

cl-async.asd.

Parent Component

src (module).

Public Interface

• dns-error (condition).
• dns-lookup (function).
• reverse-dns-lookup (function).

Internals

• dns-cb (function).
• errno-event (method).
• reverse-dns-cb (function).

---

4.1.6 cl-async/src/streamish.lisp

Dependencies

• event-loop.lisp (file).
• event.lisp (file).
• dns.lisp (file).

Source

cl-async.asd.

Parent Component

src (module).

Public Interface

• check-streamish-open (function).
• close-streamish (generic function).
• socket-closed (condition).
• streamish (generic function).
• (setf streamish) (writer method).
• streamish (class).
• streamish-broken-pipe (condition).
• streamish-canceled (condition).
• streamish-closed (reader method).
• (setf streamish-closed) (writer method).
• streamish-closed (condition).
• streamish-closed-p (function).
• streamish-enoent (condition).
• streamish-eof (condition).
• streamish-error (condition).
• streamish-info (condition).
• streamish-write (generic function).
• tcp-socket (reader method).
• (setf tcp-socket) (writer method).

Internals

• do-close-streamish (function).
• errno-event (generic function).
• event-handler (function).
• streamish-alloc-cb (function).
• streamish-c (reader method).
• (setf streamish-c) (writer method).
• streamish-close-cb (function).
• streamish-convert-data (function).
• streamish-data (reader method).
• (setf streamish-data) (writer method).
• streamish-drain-read-buffer (reader method).
• (setf streamish-drain-read-buffer) (writer method).
• streamish-read-cb (function).
• streamish-read-start (function).
• streamish-shutdown-cb (function).
• streamish-write-cb (function).
• write-to-uvstream (function).

---

4.1.7 cl-async/src/async-stream.lisp

Dependency

streamish.lisp (file).

Source

cl-async.asd.

Parent Component

src (module).

Public Interface

• async-input-stream (class).
• async-io-stream (class).
• async-output-stream (class).
• async-stream (class).
• close (method).
• open-stream-p (method).
• stream-clear-input (method).
• stream-clear-output (method).
• stream-element-type (method).
• stream-finish-output (method).
• stream-force-output (method).
• stream-read-byte (method).
• stream-read-sequence (method).
• stream-socket (function).
• stream-write-byte (method).
• stream-write-sequence (method).
• streamish (reader method).
• (setf streamish) (writer method).

Internals

• send-buffered-data (method).
• stream-append-bytes (method).
• stream-buffer (reader method).
• (setf stream-buffer) (writer method).
• stream-output-type (method).

---

4.1.8 cl-async/src/socket.lisp

Dependencies

• streamish.lisp (file).
• async-stream.lisp (file).

Source

cl-async.asd.

Parent Component

src (module).

Public Interface

• close-socket (function).
• close-socket-server (generic function).
• close-streamish (method).
• disable-socket (function).
• enable-socket (function).
• initialize-instance (method).
• initialize-instance (method).
• set-socket-timeouts (function).
• socket (method).
• socket (reader method).
• (setf socket) (writer method).
• socket (class).
• socket-aborted (condition).
• socket-accept-error (condition).
• socket-accept-error-listener (reader method).
• (setf socket-accept-error-listener) (writer method).
• socket-address-in-use (condition).
• socket-c (reader method).
• (setf socket-c) (writer method).
• socket-closed (reader method).
• (setf socket-closed) (writer method).
• socket-closed-p (function).
• socket-data (reader method).
• (setf socket-data) (writer method).
• socket-eof (condition).
• socket-error (condition).
• socket-info (condition).
• socket-refused (condition).
• socket-reset (condition).
• socket-timeout (condition).
• streamish-write (method).
• tcp-accept-error (condition).
• tcp-eof (condition).
• tcp-error (condition).
• tcp-info (condition).
• tcp-refused (condition).
• tcp-reset (condition).
• tcp-timeout (condition).
• write-socket-data (function).

Internals

• check-socket-open (function).
• errno-event (method).
• errno-event (method).
• errno-event (method).
• errno-event (method).
• errno-event (method).
• errno-event (method).
• handle-cleanup (method).
• init-client-socket (function).
• init-incoming-socket (function).
• make-socket-handle (generic function).
• server-socket-class (generic function).
• socket-accept-cb (function).
• socket-accept-error-server (reader method).
• (setf socket-accept-error-server) (writer method).
• socket-address (reader method).
• (setf socket-address) (writer method).
• socket-buffer (reader method).
• (setf socket-buffer) (writer method).
• socket-buffering-p (reader method).
• (setf socket-buffering-p) (writer method).
• socket-connect-cb (function).
• socket-connected (reader method).
• (setf socket-connected) (writer method).
• socket-drain-read-buffer (reader method).
• (setf socket-drain-read-buffer) (writer method).
• socket-server (function).
• socket-server (class).
• socket-server-bind (generic function).
• socket-server-c (reader method).
• (setf socket-server-c) (writer method).
• socket-server-closed (reader method).
• (setf socket-server-closed) (writer method).
• socket-server-stream (reader method).
• (setf socket-server-stream) (writer method).
• write-pending-socket-data (generic function).

---

4.1.9 cl-async/src/tcp.lisp

Dependencies

• dns.lisp (file).
• socket.lisp (file).

Source

cl-async.asd.

Parent Component

src (module).

Public Interface

• close-streamish (method).
• close-tcp-server (function).
• connect-tcp-socket (function).
• initialize-instance (method).
• tcp-connect (function).
• tcp-server (function).
• tcp-server (class).
• tcp-server-bind-error (condition).
• tcp-socket (class).

Internals

• handle-cleanup (method).
• make-socket-handle (method).
• server-socket-class (method).
• socket-direction (reader method).
• (setf socket-direction) (writer method).
• socket-server-bind (method).
• tcp-connect-new (function).
• tcp-mixin (class).
• tcp-server-bind-error-addr (reader method).
• (setf tcp-server-bind-error-addr) (writer method).
• tcp-server-bind-error-port (reader method).
• (setf tcp-server-bind-error-port) (writer method).
• tcp-server-closed (function).
• tcp-server-new (function).

---

4.1.10 cl-async/src/filesystem.lisp

Dependencies

• streamish.lisp (file).
• tcp.lisp (file).

Source

cl-async.asd.

Parent Component

src (module).

Public Interface

• filesystem-eacces (condition).
• filesystem-enoent (condition).
• filesystem-eperm (condition).
• filesystem-error (condition).
• mkdtemp (function).

Internals

• errno-event (method).
• errno-event (method).
• errno-event (method).
• fs-cb (function).

---

4.1.11 cl-async/src/pipe.lisp

Dependencies

• socket.lisp (file).
• filesystem.lisp (file).

Source

cl-async.asd.

Parent Component

src (module).

Public Interface

• pipe-connect (function).
• pipe-server (function).
• pipe-server (class).

Internals

• %pipe-connect (function).
• handle-cleanup (method).
• make-socket-handle (method).
• pipe (class).
• pipe-mixin (class).
• server-socket-class (method).
• socket-server-bind (method).

---

4.1.12 cl-async/src/signal.lisp

Dependencies

• streamish.lisp (file).
• pipe.lisp (file).

Source

cl-async.asd.

Parent Component

src (module).

Public Interface

• +sigabrt+ (constant).
• +sigalrm+ (constant).
• +sigbus+ (constant).
• +sigchld+ (constant).
• +sigcont+ (constant).
• +sigemt+ (constant).
• +sigfpe+ (constant).
• +sighup+ (constant).
• +sigill+ (constant).
• +siginfo+ (constant).
• +sigint+ (constant).
• +sigio+ (constant).
• +sigkill+ (constant).
• +sigpipe+ (constant).
• +sigprof+ (constant).
• +sigquit+ (constant).
• +sigsegv+ (constant).
• +sigstop+ (constant).
• +sigsys+ (constant).
• +sigterm+ (constant).
• +sigtrap+ (constant).
• +sigtstp+ (constant).
• +sigttin+ (constant).
• +sigttou+ (constant).
• +sigurg+ (constant).
• +sigusr1+ (constant).
• +sigusr2+ (constant).
• +sigvtalrm+ (constant).
• +sigwinch+ (constant).
• +sigxcpu+ (constant).
• +sigxfsz+ (constant).
• clear-signal-handlers (function).
• free-signal-handler (function).
• signal-handler (function).

Internals

• lisp-signal-cb (function).
• set-lisp-signal-handler (function).
• signal-cb (function).
• signal-close-cb (function).
• signal-pointer (function).

---

4.1.13 cl-async/src/notify.lisp

Dependencies

• streamish.lisp (file).
• signal.lisp (file).

Source

cl-async.asd.

Parent Component

src (module).

Public Interface

• free-notifier (function).
• make-notifier (function).
• notifier (class).
• notifier-freed-p (reader method).
• ref (method).
• trigger-notifier (function).
• unref (method).

Internals

• async-cb (function).
• async-close-cb (function).
• check-notifier-unfreed (function).
• handle-cleanup (method).
• notifier-c (reader method).
• (setf notifier-c) (writer method).
• notifier-freed (reader method).
• (setf notifier-freed) (writer method).
• notifier-freed (condition).
• notifier-freed-notifier (reader method).
• (setf notifier-freed-notifier) (writer method).
• notifier-single-shot (reader method).
• (setf notifier-single-shot) (writer method).
• notifier-single-shot-p (reader method).

---

4.1.14 cl-async/src/poll.lisp

Dependencies

• streamish.lisp (file).
• notify.lisp (file).

Source

cl-async.asd.

Parent Component

src (module).

Public Interface

• free-poller (function).
• poll (function).
• poller (class).
• poller-freed-p (reader method).

Internals

• poll-cb (function).
• poll-close-cb (function).
• poller-c (reader method).
• (setf poller-c) (writer method).
• poller-freed (reader method).
• (setf poller-freed) (writer method).

---

4.1.15 cl-async/src/idle.lisp

Dependencies

• package.lisp (file).
• poll.lisp (file).

Source

cl-async.asd.

Parent Component

src (module).

Public Interface

• free-idler (function).
• idle (function).
• idler (class).
• idler-freed-p (reader method).

Internals

• idle-cb (function).
• idle-close-cb (function).
• idler-c (reader method).
• (setf idler-c) (writer method).
• idler-freed (reader method).
• (setf idler-freed) (writer method).

---

4.1.16 cl-async/src/process.lisp

Dependencies

• pipe.lisp (file).
• idle.lisp (file).

Source

cl-async.asd.

Parent Component

src (module).

Public Interface

• initialize-instance (method).
• process-error-output (reader method).
• (setf process-error-output) (writer method).
• process-input (reader method).
• (setf process-input) (writer method).
• process-kill (function).
• process-output (reader method).
• (setf process-output) (writer method).
• spawn (function).

Internals

• handle-cleanup (method).
• init-stdio-container (function).
• process (class).
• process-c (reader method).
• (setf process-c) (writer method).
• process-close (function).
• process-close-cb (function).
• process-exit-cb (function).

---

4.1.17 cl-async/src/fsevent.lisp

Dependencies

• streamish.lisp (file).
• process.lisp (file).

Source

cl-async.asd.

Parent Component

src (module).

Public Interface

• fs-monitor-close (function).
• fs-unwatch (function).
• fs-watch (function).
• initialize-instance (method).

Internals

• %fs-monitor-close (function).
• fs-event-callback (function).
• fs-monitor (class).
• fs-monitor-c (reader method).
• (setf fs-monitor-c) (writer method).
• fs-monitor-close-cb (function).
• handle-cleanup (method).

---

4.1.18 cl-async-base/src/base.lisp

Source

cl-async.asd.

Parent Component

cl-async-base (system).

Packages

cl-async-base.

Public Interface

• *buffer-size* (special variable).
• *buffer-writes* (special variable).
• *data-registry* (special variable).
• *enable-threading* (special variable).
• *event-base* (special variable).
• *event-base-next-id* (special variable).
• *function-registry* (special variable).
• *input-buffer* (special variable).
• *output-buffer* (special variable).
• *safe-sldb-quit-restart* (special variable).
• event-base (class).
• event-base-c (reader method).
• (setf event-base-c) (writer method).
• event-base-catch-app-errors (reader method).
• (setf event-base-catch-app-errors) (writer method).
• event-base-data-registry (reader method).
• (setf event-base-data-registry) (writer method).
• event-base-dns-base (reader method).
• (setf event-base-dns-base) (writer method).
• event-base-dns-ref-count (reader method).
• (setf event-base-dns-ref-count) (writer method).
• event-base-exit-functions (reader method).
• (setf event-base-exit-functions) (writer method).
• event-base-function-registry (reader method).
• (setf event-base-function-registry) (writer method).
• event-base-id (reader method).
• (setf event-base-id) (writer method).
• event-base-lock (reader method).
• (setf event-base-lock) (writer method).
• event-base-num-connections-in (reader method).
• (setf event-base-num-connections-in) (writer method).
• event-base-num-connections-out (reader method).
• (setf event-base-num-connections-out) (writer method).
• event-base-send-errors-to-eventcb (reader method).
• (setf event-base-send-errors-to-eventcb) (writer method).
• event-base-signal-handlers (reader method).
• (setf event-base-signal-handlers) (writer method).
• event-errcode (reader method).
• event-errmsg (reader method).
• event-error (condition).
• event-info (condition).

---

4.1.19 cl-async-util/src/util/package.lisp

Source

cl-async.asd.

Parent Component

cl-async-util (system).

Packages

cl-async-util.

---

4.1.20 cl-async-util/src/util/helpers.lisp

Dependency

src/util/package.lisp (file).

Source

cl-async.asd.

Parent Component

cl-async-util (system).

Public Interface

• *ipv4-scanner* (special variable).
• *ipv6-scanner* (special variable).
• append-array (function).
• attach-data-to-pointer (function).
• buffer-output (function).
• bytes (function).
• bytes-or-string (type).
• callback (type).
• clear-callbacks (function).
• clear-pointer-data (function).
• create-data-pointer (function).
• define-condition-alias (macro).
• deref-data-from-pointer (function).
• do-chunk-data (function).
• free-pointer-data (function).
• get-callbacks (function).
• ip-address-p (function).
• ipv4-address-p (function).
• ipv6-address-p (function).
• make-buffer (function).
• make-pointer-eql-able (function).
• octet (type).
• octet-vector (type).
• save-callbacks (function).
• with-lock (macro).
• write-to-buffer (function).

---

4.1.21 cl-async-util/src/util/foreign.lisp

Dependency

src/util/helpers.lisp (file).

Source

cl-async.asd.

Parent Component

cl-async-util (system).

Public Interface

• +af-inet+ (constant).
• +af-inet6+ (constant).
• +af-unix+ (constant).
• +af-unspec+ (constant).
• addrinfo-to-string (function).
• define-c-callback (macro).
• error-str (function).
• fd-connected-p (function).
• ip-str-to-sockaddr (function).
• set-socket-nonblocking (function).
• with-foreign-object* (macro).
• with-ip-to-sockaddr (macro).

---

4.1.22 cl-async-util/src/util/error.lisp

Dependency

src/util/foreign.lisp (file).

Source

cl-async.asd.

Parent Component

cl-async-util (system).

Public Interface

• *passthrough-errors* (special variable).
• call-with-callback-restarts (function).
• catch-app-errors (macro).
• handle-error (generic function).
• passthrough-error-p (function).
• run-event-cb (function).

Internals

*evcb-err* (special variable).

---

6.1.1 Constants

Constant: +af-inet+ ¶

Package

cl-async-util.

Source

src/util/foreign.lisp.

Constant: +af-inet6+ ¶

Package

cl-async-util.

Source

src/util/foreign.lisp.

Constant: +af-unix+ ¶

Package

cl-async-util.

Source

src/util/foreign.lisp.

Constant: +af-unspec+ ¶

Package

cl-async-util.

Source

src/util/foreign.lisp.

Constant: +sigabrt+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigalrm+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigbus+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigchld+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigcont+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigemt+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigfpe+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sighup+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigill+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +siginfo+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigint+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigio+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigkill+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigpipe+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigprof+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigquit+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigsegv+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigstop+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigsys+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigterm+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigtrap+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigtstp+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigttin+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigttou+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigurg+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigusr1+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigusr2+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigvtalrm+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigwinch+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigxcpu+ ¶

Package

cl-async.

Source

signal.lisp.

Constant: +sigxfsz+ ¶

Package

cl-async.

Source

signal.lisp.

---

6.1.2 Special variables

Special Variable: *buffer-size* ¶

The amount of data we’ll pull from the evbuffers when doing reading/writing.

Package

cl-async-base.

Source

src/base.lisp.

Special Variable: *buffer-writes* ¶

If T, will buffer writes on the socket until the next loop. This is mainly to cut down on calls to uv_write, which is fairly slow.

Package

cl-async-base.

Source

src/base.lisp.

Special Variable: *data-registry* ¶

A hash table holding C pointer -> lisp data mappings.

Package

cl-async-base.

Source

src/base.lisp.

Special Variable: *enable-threading* ¶

If true, various pieces of the cl-async internals will lock their restecpive structures before operating to ensure thread safety.

Package

cl-async-base.

Source

src/base.lisp.

Special Variable: *event-base* ¶

THE event base object used to process all async operations.

Package

cl-async-base.

Source

src/base.lisp.

Special Variable: *event-base-next-id* ¶

The numeric identifier assigned to each new event base.

Package

cl-async-base.

Source

src/base.lisp.

Special Variable: *function-registry* ¶

A hash table holding C pointer -> lisp function(s) mappings.

Package

cl-async-base.

Source

src/base.lisp.

Special Variable: *input-buffer* ¶

A buffer that lives in both C and lisp worlds (static-vector) that lets us read from sockets.

Package

cl-async-base.

Source

src/base.lisp.

Special Variable: *ipv4-scanner* ¶

Scanner that detects if a string is an IPV4 address.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Special Variable: *ipv6-scanner* ¶

Scanner that detects if a string is an IPV6 address.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Special Variable: *output-buffer* ¶

A buffer that lives in both C and lisp worlds (static-vector) that lets us write to sockets.

Package

cl-async-base.

Source

src/base.lisp.

Special Variable: *passthrough-errors* ¶

Package

cl-async-util.

Source

src/util/error.lisp.

Special Variable: *safe-sldb-quit-restart* ¶

If true, provides a safe default for SLIME debugger quit restart (ABORT-CALLBACK). This restart causes the callback to be aborted without quitting the event loop. If false, the default restart is set to EXIT-EVENT-LOOP.

Package

cl-async-base.

Source

src/base.lisp.

---

6.1.3 Macros

Macro: catch-app-errors (event-cb &body body) ¶

Handle error conditions by directing them to the specified event callback or default event handler of the current event loop, if catching app errors is enabled for the current event loop via EVENT-BASE-CATCH-APP-ERRORS, otherwise just evaluate the BODY.

If event-cbs are called via run-event-cb, make sure the event-cb is NOT double-called with the same condition twice.

Package

cl-async-util.

Source

src/util/error.lisp.

Macro: define-c-callback (name return-val (&rest args) &body body) ¶

Define a top-level function with the given and also define a C callback that calls the function directly. The idea is that CFFI callbacks aren’t directly callable/debuggable, but it’s obnoxious to have to define and callback *and* a function right next to each other.

Package

cl-async-util.

Source

src/util/foreign.lisp.

Macro: define-condition-alias (alias name) ¶

Define an alias for the specified condition.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Macro: with-delay ((&optional seconds) &body body) ¶

Nicer syntax for delay function.

Package

cl-async.

Source

event.lisp.

Macro: with-event-loop ((&key catch-app-errors send-errors-to-eventcb) &body body) ¶

Makes starting an event loop a tad less annoying. I really couldn’t take typing out ‘(start-event-loop (lambda () ...) ...) every time. Example:

(with-event-loop (:catch-app-errors t) (do-something-one-does-when-an-event-loop-is-running))

See how nice that is?

Package

cl-async.

Source

event-loop.lisp.

Macro: with-foreign-object* ((var type &key zero initial) bindings &body body) ¶

Convenience macro, makes creation and initialization of CFFI types easier. Emphasis on initialization.

Package

cl-async-util.

Source

src/util/foreign.lisp.

Macro: with-interval ((seconds) &body body) ¶

Nicer syntax for interval function.

Package

cl-async.

Source

event.lisp.

Macro: with-ip-to-sockaddr (((bind) address port) &body body) ¶

Wraps around ipv4-str-to-sockaddr. Converts a string address and port and creates a sockaddr-in object, runs the body with it bound, and frees it.

Package

cl-async-util.

Source

src/util/foreign.lisp.

Macro: with-lock (&body body) ¶

If threading is enabled, locks the current event loop before processing body and releases the lock after body is finished.

Package

cl-async-util.

Source

src/util/helpers.lisp.

---

6.1.4 Ordinary functions

Function: add-event (event &key timeout activate) ¶

Add an event to its specified event loop (make it pending). If given a :timeout (in seconds) the event will fire after that amount of time, unless it’s removed or freed.

Package

cl-async.

Source

event.lisp.

Function: add-event-loop-exit-callback (fn) ¶

Add a function to be run when the event loop exits.

Package

cl-async.

Source

event-loop.lisp.

Function: addrinfo-to-string (addrinfo) ¶

Given a (horrible) addrinfo C object pointer, grab either an IP4 or IP6 address and return is as a string.

Package

cl-async-util.

Source

src/util/foreign.lisp.

Function: append-array (arr1 arr2) ¶

Create an array, made up of arr1 followed by arr2.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Function: attach-data-to-pointer (pointer data) ¶

Attach a lisp object to a foreign pointer.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Function: buffer-output (buffer) ¶

Grab the output from a buffer created with (make-buffer).

Package

cl-async-util.

Source

src/util/helpers.lisp.

Function: bytes (vector) ¶

Convert any vector/string into a byte array. Useful for sending direct byte data into write-socket-data.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Function: call-with-callback-restarts (thunk &key continue-fn abort-restart-description) ¶

Call thunk with restarts that make it possible to ignore the callback in case of an error or safely terminate the event loop.

If SWANK is active, set SLDB’s quit restart to ABORT-CALLBACK restart if *safe-sldb-quit-restart* is true or EXIT-EVENT-LOOP otherwise.

Package

cl-async-util.

Source

src/util/error.lisp.

Function: check-streamish-open (streamish) ¶

Throw a streamish-closed condition if given a streamish that’s closed.

Package

cl-async.

Source

streamish.lisp.

Function: clear-callbacks (pointer) ¶

Clear out all callbacks for the given pointer.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Function: clear-pointer-data (pointer) ¶

Clear the data attached to a CFFI pointer.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Function: clear-signal-handlers () ¶

Clear all bound signal handlers. Great for cleaning up when exiting an app.

Package

cl-async.

Source

signal.lisp.

Function: close-socket (socket &key force) ¶

Free a socket (uvstream) and clear out all associated data. Same as close-streamish.

Package

cl-async.

Source

socket.lisp.

Function: close-tcp-server (server) ¶

Package

cl-async.

Source

tcp.lisp.

Function: connect-tcp-socket (socket/stream host port &key event-cb) ¶

Connect a tcp socket initialized with init-client-socket.

Package

cl-async.

Source

tcp.lisp.

Function: create-data-pointer () ¶

Creates a pointer in C land that can be used to attach data/callbacks to. Note that this must be freed via clear-pointer-data.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Function: delay (callback &key time event-cb) ¶

Run a function, asynchronously, after the specified amount of seconds. An event loop must be running for this to work.

If time is nil, callback is still called asynchronously, but is queued in the event loop with no delay.

Package

cl-async.

Source

event.lisp.

Function: deref-data-from-pointer (pointer) ¶

Grab data attached to a CFFI pointer.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Function: disable-socket (socket &key read write) ¶

Disable read/write monitoring on a socket. If :read or :write are nil, they are not enabled, but rather just not disabled.

Package

cl-async.

Source

socket.lisp.

Function: dns-lookup (host resolve-cb &key event-cb family) ¶

Asynchronously lookup a DNS address. Note that if an IP address is passed, the lookup happens synchronously. If a lookup is synchronous (and instant) this returns T, otherwise nil (lookup happening in background). Either way the resolve-cb is called with the lookup info (so always assume this is async).

Package

cl-async.

Source

dns.lisp.

Function: do-chunk-data (data buffer write-cb &key start end new-buffer) ¶

Util function that splits data into the (length buffer) chunks and calls write-cb for each chunk.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Function: dump-event-loop-status () ¶

Return the status of the event loop. Really a debug function more than anything else.

Package

cl-async.

Source

event-loop.lisp.

Function: enable-socket (socket &key read write) ¶

Enable read/write monitoring on a socket. If :read or :write are nil, they are not disabled, but rather just not enabled.

Package

cl-async.

Source

socket.lisp.

Function: error-str (uv-errno) ¶

Given a libuv error number, return the error string.

Package

cl-async-util.

Source

src/util/foreign.lisp.

Function: exit-event-loop () ¶

Exit the event loop if running.

Package

cl-async.

Source

event-loop.lisp.

Function: fd-connected-p (fd) ¶

Check if an FD is connected.

Package

cl-async-util.

Source

src/util/foreign.lisp.

Function: free-event (event) ¶

Free a cl-async event object and any resources it uses.

Package

cl-async.

Source

event.lisp.

Function: free-idler (idler) ¶

Stop and free an idler.

Package

cl-async.

Source

idle.lisp.

Function: free-notifier (notifier) ¶

Free a cl-async notifier object and any resources it uses.

Package

cl-async.

Source

notify.lisp.

Function: free-pointer-data (pointer &key preserve-pointer) ¶

Clears out all data attached to a foreign pointer, and frees the pointer (unless :preserve-pointer is t).

Package

cl-async-util.

Source

src/util/helpers.lisp.

Function: free-poller (poller) ¶

Stop and free a poller.

Package

cl-async.

Source

poll.lisp.

Function: free-signal-handler (signo) ¶

Clear a signal handler and unbind it.

Package

cl-async.

Source

signal.lisp.

Function: fs-monitor-close (fs-monitor) ¶

Package

cl-async.

Source

fsevent.lisp.

Function: fs-unwatch (fs-monitor) ¶

Package

cl-async.

Source

fsevent.lisp.

Function: fs-watch (path callback &key event-cb) ¶

Package

cl-async.

Source

fsevent.lisp.

Function: get-callbacks (pointer) ¶

Get all callbacks for the given pointer.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Function: idle (callback &key event-cb) ¶

Calls ‘callback‘ once per event loop.

Package

cl-async.

Source

idle.lisp.

Function: interval (callback &key time event-cb) ¶

Run a function, asynchronously, every ‘time‘ seconds. This function returns a function which, when called, cancels the interval.

Package

cl-async.

Source

event.lisp.

Function: ip-address-p (addr) ¶

Determine if the given host is an IP or a hostname.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Function: ip-str-to-sockaddr (address port) ¶

Convert a string IP address and port into a sockaddr-in struct. Must be freed by the app!

Package

cl-async-util.

Source

src/util/foreign.lisp.

Function: ipv4-address-p (addr) ¶

Determine if the given host is an IPV4 addr or a hostname.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Function: ipv6-address-p (addr) ¶

Determine if the given host is an IPV6 addr or a hostname.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Function: make-buffer (&optional data) ¶

Create an octet buffer, optoinally filled with the given data.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Function: make-event (callback &key event-cb) ¶

Make an arbitrary event, and add it to the event loop. It *must* be triggered by (add-event <the event> :activate t) or it will sit, idle, for 100 years. Or you can remove/free it instead.

This is useful for triggering arbitrary events, and can even be triggered from a thread outside the libuv loop.

Package

cl-async.

Source

event.lisp.

Function: make-notifier (callback &key event-cb single-shot) ¶

Makes a notifier, an object that can trigger a callback from a thread other than the event loop thread. If single-shot is true (the default), free the notifier after it’s triggered.

Package

cl-async.

Source

notify.lisp.

Function: make-pointer-eql-able (pointer) ¶

Abstraction to make a CFFI pointer #’eql to itself. Does its best to be the most performant for the current implementation.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Function: mkdtemp (template cb &key event-cb) ¶

Package

cl-async.

Source

filesystem.lisp.

Function: passthrough-error-p (e) ¶

Return true if the specified error condition should not be intercepted by cl-async error handling mechanism.

Package

cl-async-util.

Source

src/util/error.lisp.

Function: pipe-connect (name read-cb &key data stream event-cb connect-cb write-cb read-timeout write-timeout dont-drain-read-buffer) ¶

Open a pipe connection asynchronously. Optionally send data out once connected via the :data keyword (can be a string or byte array).

Package

cl-async.

Source

pipe.lisp.

Function: pipe-server (name read-cb &key event-cb connect-cb backlog stream fd) ¶

Start a pipe listener on the current event loop. Returns a tcp-server class which can be closed with close-tcp-server

Package

cl-async.

Source

pipe.lisp.

Function: poll (fd poll-cb &key event-cb poll-for socket) ¶

Poll an OS FD. If the FD is a socket, :socket t must be passed.

Package

cl-async.

Source

poll.lisp.

Function: process-kill (process signal &key event-cb) ¶

If PROCESS is active, send the specified signal (an integer) to it and return true. If PROCESS is not active or an error occurs (and EVENT-CB doesn’t
signal an error), return false. If EVENT-CB is specified, use it
to handle errors, otherwise signal them via ERROR.

Package

cl-async.

Source

process.lisp.

Function: remove-event (event) ¶

Remove a pending event from the event loop.

Package

cl-async.

Source

event.lisp.

Function: remove-interval (interval-fn) ¶

Stops an interval from looping.

Package

cl-async.

Source

event.lisp.

Function: reverse-dns-lookup (ip resolve-cb &key event-cb) ¶

Perform reverse DNS lookup on IP specifier as string. Call RESOLVE-CB with resolved HOST and SERVICE as strings. The callback is called once with one host, even if multiple hosts match the query.

Package

cl-async.

Source

dns.lisp.

Function: run-event-cb (event-cb &rest args) ¶

When used in the dynamic context of catch-app-errors, wraps the calling of an event-cb with args such that errors are caught and saved, ensuring that an event-cb isn’t called twice with the same condition. When used outside the dynamic context of catch-app-errors, just invokes event-cb with args.

Package

cl-async-util.

Source

src/util/error.lisp.

Function: save-callbacks (pointer callbacks) ¶

Save a set of callbacks, keyed by the given pointer.

Package

cl-async-util.

Source

src/util/helpers.lisp.

Function: set-socket-nonblocking (fd) ¶

Sets an FD into non-blocking mode.

Package

cl-async-util.

Source

src/util/foreign.lisp.

Function: set-socket-timeouts (socket read-sec write-sec &key socket-is-uvstream) ¶

Set the read/write timeouts on a socket.

Package

cl-async.

Source

socket.lisp.

Function: signal-handler (signo signal-cb &key event-cb) ¶

Setup a one-time signal handler for the given signo. This also sets up a lisp signal handler, so if a signal comes through while lisp is running instead of the event loop, it will run the same callback. All signal handlers are restored on event loop exit.

Package

cl-async.

Source

signal.lisp.

Function: socket-closed-p (socket) ¶

Return whether a socket is closed or not. Same as streamish-closed-p.

Package

cl-async.

Source

socket.lisp.

Function: spawn (path args &key exit-cb event-cb input output error-output env working-directory) ¶

Run the program specified by PATH with specified ARGS.
ARGS don’t include the executable path (argv[0]). Return process object and pipes or streams for input, output and error output file descriptors of the child process (NIL for file descriptors that
aren’t redirected via :PIPE or :STREAM, see below).

EXIT-CB specifies the callback that should be called when the
program terminates. It should be a function taking three arguments: process object, exit status and signal number that caused program termination (0 if the program wasn’t terminated by signal).

EVENT-CB specifies error handler to be used.

INPUT, OUTPUT and ERROR-OUTPUT specify process input/output/error redirection. For each of these, the following values are
supported:

:IGNORE the corresponding file descriptor isn’t used
:INHERIT inherit file descriptor from this process
(:PIPE [:READ-CB ...] ...) use pipe-based redirection of the corresponding file descriptor (see PIPE-CONNECT for the set
of supported keyword arguments).
(:STREAM [:READ-CB ...] ...) same as PIPE, but uses async
stream instead of a pipe.

ENV is an alist of (VAR . VALUE) pairs specifying the environment variables of the spawned process. Note that both VAR and VALUE must be strings.

WORKING-DIRECTORY specifies the current working directory of the spawned program. Defaults to the current working directory of its parent process (viz. the process SPAWN is called from).

Package

cl-async.

Source

process.lisp.

Function: start-event-loop (start-fn &key catch-app-errors send-errors-to-eventcb) ¶

Simple wrapper function that starts an event loop which runs the given callback, most likely to init your server/client.

Package

cl-async.

Source

event-loop.lisp.

Function: stats () ¶

Return statistics about the current event loop.

Package

cl-async.

Source

event-loop.lisp.

Function: stream-socket (stream) ¶

Package

cl-async.

Source

async-stream.lisp.

Function: streamish-closed-p (streamish) ¶

Return whether a streamish is closed or not.

Package

cl-async.

Source

streamish.lisp.

Function: tcp-connect (host port read-cb &rest args) ¶

Open a TCP connection asynchronously. Optionally send data out once connected via the :data keyword (can be a string or byte array).

Package

cl-async.

Source

tcp.lisp.

Function: tcp-server (bind-address port read-cb &rest args) ¶

Open a TCP connection asynchronously. Optionally send data out once connected via the :data keyword (can be a string or byte array).

Package

cl-async.

Source

tcp.lisp.

Function: trigger-notifier (notifier) ¶

Fires the callback attached to a notifier. Can be called from any thread.

Package

cl-async.

Source

notify.lisp.

Function: write-socket-data (socket data &rest args &key &allow-other-keys) ¶

An compatibility alias for STREAMISH-WRITE.

Package

cl-async.

Source

socket.lisp.

Function: write-to-buffer (seq buffer &optional start end) ¶

Write data to a buffer created with (make-buffer).

Package

cl-async-util.

Source

src/util/helpers.lisp.

---

6.1.5 Generic functions

Generic Function: close-socket-server (socket) ¶

Closes a socket server. If already closed, does nothing.

Package

cl-async.

Source

socket.lisp.

Methods

Method: close-socket-server ((socket-server socket-server)) ¶

Generic Function: close-streamish (streamish &key force &allow-other-keys) ¶

Free a streamish (uvstream) and clear out all associated data.

Package

cl-async.

Source

streamish.lisp.

Methods

Method: close-streamish :after ((socket tcp-socket) &key &allow-other-keys) ¶

Source

tcp.lisp.

Method: close-streamish ((socket socket) &key force &allow-other-keys) ¶

Source

socket.lisp.

Method: close-streamish ((streamish streamish) &key force) ¶

Close and free a streamish and all of it’s underlying structures.

Generic Reader: event-base-c (object) ¶

Generic Writer: (setf event-base-c) (object) ¶

Package

cl-async-base.

Methods

Reader Method: event-base-c ((event-base event-base)) ¶

Writer Method: (setf event-base-c) ((event-base event-base)) ¶

Holds the C object pointing to the underlying event loop object.

Source

src/base.lisp.

Target Slot

c.

Generic Reader: event-base-catch-app-errors (object) ¶

Generic Writer: (setf event-base-catch-app-errors) (object) ¶

Package

cl-async-base.

Methods

Reader Method: event-base-catch-app-errors ((event-base event-base)) ¶

Writer Method: (setf event-base-catch-app-errors) ((event-base event-base)) ¶

If t (or a function) will trap all errors produced in the event loop and process them internally

Source

src/base.lisp.

Target Slot

catch-app-errors.

Generic Reader: event-base-data-registry (object) ¶

Generic Writer: (setf event-base-data-registry) (object) ¶

Package

cl-async-base.

Methods

Reader Method: event-base-data-registry ((event-base event-base)) ¶

Writer Method: (setf event-base-data-registry) ((event-base event-base)) ¶

Holds all callback data attached to this event loop.

Source

src/base.lisp.

Target Slot

data-registry.

Generic Reader: event-base-dns-base (object) ¶

Generic Writer: (setf event-base-dns-base) (object) ¶

Package

cl-async-base.

Methods

Reader Method: event-base-dns-base ((event-base event-base)) ¶

Writer Method: (setf event-base-dns-base) ((event-base event-base)) ¶

Holds the DNS base object used for DNS lookups.

Source

src/base.lisp.

Target Slot

dns-base.

Generic Reader: event-base-dns-ref-count (object) ¶

Generic Writer: (setf event-base-dns-ref-count) (object) ¶

Package

cl-async-base.

Methods

Reader Method: event-base-dns-ref-count ((event-base event-base)) ¶

Writer Method: (setf event-base-dns-ref-count) ((event-base event-base)) ¶

Tracks how many open requests are pending on the dns base.

Source

src/base.lisp.

Target Slot

dns-ref-count.

Generic Reader: event-base-exit-functions (object) ¶

Generic Writer: (setf event-base-exit-functions) (object) ¶

Package

cl-async-base.

Methods

Reader Method: event-base-exit-functions ((event-base event-base)) ¶

Writer Method: (setf event-base-exit-functions) ((event-base event-base)) ¶

Holds functions to be run when the event loop exist (cleanly or otherwise).

Source

src/base.lisp.

Target Slot

exit-functions.

Generic Reader: event-base-function-registry (object) ¶

Generic Writer: (setf event-base-function-registry) (object) ¶

Package

cl-async-base.

Methods

Reader Method: event-base-function-registry ((event-base event-base)) ¶

Writer Method: (setf event-base-function-registry) ((event-base event-base)) ¶

Holds all callbacks attached to this event loop.

Source

src/base.lisp.

Target Slot

function-registry.

Generic Reader: event-base-id (object) ¶

Generic Writer: (setf event-base-id) (object) ¶

Package

cl-async-base.

Methods

Reader Method: event-base-id ((event-base event-base)) ¶

Writer Method: (setf event-base-id) ((event-base event-base)) ¶

Holds this event loop’s numeric id.

Source

src/base.lisp.

Target Slot

id.

Generic Reader: event-base-lock (object) ¶

Generic Writer: (setf event-base-lock) (object) ¶

Package

cl-async-base.

Methods

Reader Method: event-base-lock ((event-base event-base)) ¶

Writer Method: (setf event-base-lock) ((event-base event-base)) ¶

Holds *the* lock for this event base.

Source

src/base.lisp.

Target Slot

lock.

Generic Reader: event-base-num-connections-in (object) ¶

Package

cl-async-base.

Methods

Reader Method: event-base-num-connections-in ((event-base event-base)) ¶

automatically generated reader method

Source

src/base.lisp.

Target Slot

num-connections-in.

Generic Writer: (setf event-base-num-connections-in) (object) ¶

Package

cl-async-base.

Methods

Writer Method: (setf event-base-num-connections-in) ((event-base event-base)) ¶

automatically generated writer method

Source

src/base.lisp.

Target Slot

num-connections-in.

Generic Reader: event-base-num-connections-out (object) ¶

Package

cl-async-base.

Methods

Reader Method: event-base-num-connections-out ((event-base event-base)) ¶

automatically generated reader method

Source

src/base.lisp.

Target Slot

num-connections-out.

Generic Writer: (setf event-base-num-connections-out) (object) ¶

Package

cl-async-base.

Methods

Writer Method: (setf event-base-num-connections-out) ((event-base event-base)) ¶

automatically generated writer method

Source

src/base.lisp.

Target Slot

num-connections-out.

Generic Reader: event-base-send-errors-to-eventcb (object) ¶

Generic Writer: (setf event-base-send-errors-to-eventcb) (object) ¶

Package

cl-async-base.

Methods

Reader Method: event-base-send-errors-to-eventcb ((event-base event-base)) ¶

Writer Method: (setf event-base-send-errors-to-eventcb) ((event-base event-base)) ¶

If t, will send caught errors to the event-cb instead of handle-error

Source

src/base.lisp.

Target Slot

send-errors-to-eventcb.

Generic Reader: event-base-signal-handlers (object) ¶

Generic Writer: (setf event-base-signal-handlers) (object) ¶

Package

cl-async-base.

Methods

Reader Method: event-base-signal-handlers ((event-base event-base)) ¶

Writer Method: (setf event-base-signal-handlers) ((event-base event-base)) ¶

Holds all signal handlers.

Source

src/base.lisp.

Target Slot

signal-handlers.

Generic Reader: event-c (object) ¶

Package

cl-async.

Methods

Reader Method: event-c ((event event)) ¶

automatically generated reader method

Source

event.lisp.

Target Slot

c.

Generic Writer: (setf event-c) (object) ¶

Package

cl-async.

Methods

Writer Method: (setf event-c) ((event event)) ¶

automatically generated writer method

Source

event.lisp.

Target Slot

c.

Generic Reader: event-errcode (condition) ¶

Package

cl-async-base.

Methods

Reader Method: event-errcode ((condition event-error)) ¶

Source

src/base.lisp.

Target Slot

code.

Generic Reader: event-errmsg (condition) ¶

Package

cl-async-base.

Methods

Reader Method: event-errmsg ((condition event-error)) ¶

Source

src/base.lisp.

Target Slot

msg.

Generic Reader: event-freed (object) ¶

Package

cl-async.

Methods

Reader Method: event-freed ((event event)) ¶

automatically generated reader method

Source

event.lisp.

Target Slot

freed.

Generic Writer: (setf event-freed) (object) ¶

Package

cl-async.

Methods

Writer Method: (setf event-freed) ((event event)) ¶

automatically generated writer method

Source

event.lisp.

Target Slot

freed.

Generic Reader: event-freed-p (object) ¶

Package

cl-async.

Methods

Reader Method: event-freed-p ((event event)) ¶

automatically generated reader method

Source

event.lisp.

Target Slot

freed.

Generic Function: handle-error (error) ¶

Default error handler responsible for handling uncaught errors.

Package

cl-async-util.

Source

src/util/error.lisp.

Methods

Method: handle-error (error) ¶

Generic Reader: idler-freed-p (object) ¶

Package

cl-async.

Methods

Reader Method: idler-freed-p ((idler idler)) ¶

automatically generated reader method

Source

idle.lisp.

Target Slot

freed.

Generic Reader: notifier-freed-p (object) ¶

Package

cl-async.

Methods

Reader Method: notifier-freed-p ((notifier notifier)) ¶

automatically generated reader method

Source

notify.lisp.

Target Slot

freed.

Generic Reader: poller-freed-p (object) ¶

Package

cl-async.

Methods

Reader Method: poller-freed-p ((poller poller)) ¶

automatically generated reader method

Source

poll.lisp.

Target Slot

freed.

Generic Reader: process-error-output (object) ¶

Package

cl-async.

Methods

Reader Method: process-error-output ((process process)) ¶

automatically generated reader method

Source

process.lisp.

Target Slot

error-output.

Generic Writer: (setf process-error-output) (object) ¶

Package

cl-async.

Methods

Writer Method: (setf process-error-output) ((process process)) ¶

automatically generated writer method

Source

process.lisp.

Target Slot

error-output.

Generic Reader: process-input (object) ¶

Package

cl-async.

Methods

Reader Method: process-input ((process process)) ¶

automatically generated reader method

Source

process.lisp.

Target Slot

input.

Generic Writer: (setf process-input) (object) ¶

Package

cl-async.

Methods

Writer Method: (setf process-input) ((process process)) ¶

automatically generated writer method

Source

process.lisp.

Target Slot

input.

Generic Reader: process-output (object) ¶

Package

cl-async.

Methods

Reader Method: process-output ((process process)) ¶

automatically generated reader method

Source

process.lisp.

Target Slot

output.

Generic Writer: (setf process-output) (object) ¶

Package

cl-async.

Methods

Writer Method: (setf process-output) ((process process)) ¶

automatically generated writer method

Source

process.lisp.

Target Slot

output.

Generic Function: ref (handle) ¶

Reference a libuv handle object (uv_ref)

Package

cl-async.

Source

event-loop.lisp.

Methods

Method: ref ((handle notifier)) ¶

Source

notify.lisp.

Method: ref ((handle event)) ¶

Source

event.lisp.

Generic Function: socket (condition) ¶

Package

cl-async.

Methods

Method: socket (thing) ¶

Source

socket.lisp.

Reader Method: socket ((condition tcp-info)) ¶

Source

socket.lisp.

Target Slot

streamish.

Generic Writer: (setf socket) (condition) ¶

Package

cl-async.

Methods

Writer Method: (setf socket) ((condition tcp-info)) ¶

Source

socket.lisp.

Target Slot

streamish.

Generic Reader: socket-accept-error-listener (condition) ¶

Generic Writer: (setf socket-accept-error-listener) (condition) ¶

Package

cl-async.

Methods

Reader Method: socket-accept-error-listener ((condition tcp-accept-error)) ¶

Writer Method: (setf socket-accept-error-listener) ((condition tcp-accept-error)) ¶

Source

socket.lisp.

Target Slot

listener.

Generic Reader: socket-c (object) ¶

Package

cl-async.

Methods

Reader Method: socket-c ((socket socket)) ¶

automatically generated reader method

Source

socket.lisp.

Target Slot

c.

Generic Writer: (setf socket-c) (object) ¶

Package

cl-async.

Methods

Writer Method: (setf socket-c) ((socket socket)) ¶

automatically generated writer method

Source

socket.lisp.

Target Slot

c.

Generic Reader: socket-closed (object) ¶

Package

cl-async.

Methods

Reader Method: socket-closed ((socket socket)) ¶

automatically generated reader method

Source

socket.lisp.

Target Slot

closed.

Generic Writer: (setf socket-closed) (object) ¶

Package

cl-async.

Methods

Writer Method: (setf socket-closed) ((socket socket)) ¶

automatically generated writer method

Source

socket.lisp.

Target Slot

closed.

Generic Reader: socket-data (object) ¶

Package

cl-async.

Methods

Reader Method: socket-data ((socket socket)) ¶

automatically generated reader method

Source

socket.lisp.

Target Slot

data.

Generic Writer: (setf socket-data) (object) ¶

Package

cl-async.

Methods

Writer Method: (setf socket-data) ((socket socket)) ¶

automatically generated writer method

Source

socket.lisp.

Target Slot

data.

Generic Function: streamish (thing) ¶

Returned associated streamish for THING or THING itself if THING is a streamish.

Package

cl-async.

Source

streamish.lisp.

Methods

Reader Method: streamish ((async-stream async-stream)) ¶

automatically generated reader method

Source

async-stream.lisp.

Target Slot

streamish.

Method: streamish ((streamish streamish)) ¶

Reader Method: streamish ((condition streamish-info)) ¶

Target Slot

streamish.

Generic Writer: (setf streamish) (condition) ¶

Package

cl-async.

Methods

Writer Method: (setf streamish) ((async-stream async-stream)) ¶

automatically generated writer method

Source

async-stream.lisp.

Target Slot

streamish.

Writer Method: (setf streamish) ((condition streamish-info)) ¶

Source

streamish.lisp.

Target Slot

streamish.

Generic Reader: streamish-closed (object) ¶

Package

cl-async.

Methods

Reader Method: streamish-closed ((streamish streamish)) ¶

automatically generated reader method

Source

streamish.lisp.

Target Slot

closed.

Generic Writer: (setf streamish-closed) (object) ¶

Package

cl-async.

Methods

Writer Method: (setf streamish-closed) ((streamish streamish)) ¶

automatically generated writer method

Source

streamish.lisp.

Target Slot

closed.

Generic Function: streamish-write (streamish data &key start end force read-cb write-cb event-cb &allow-other-keys) ¶

Write data into a streamish. Allows specifying read/write/event
callbacks. Any callback left nil will use that current callback from the streamish (so they only override when specified, otherwise keep the current callback).

Note that libuv doesn’t buffer output for non-connected sockets, so we have to do it ourselves by checking if the socket is connected and buffering accordingly.

Package

cl-async.

Source

streamish.lisp.

Methods

Method: streamish-write ((socket socket) data &key start end force &allow-other-keys) ¶

Source

socket.lisp.

Method: streamish-write :around ((streamish streamish) data &key read-cb write-cb event-cb &allow-other-keys) ¶

Method: streamish-write ((streamish streamish) data &key start end &allow-other-keys) ¶

Generic Reader: tcp-socket (condition) ¶

Generic Writer: (setf tcp-socket) (condition) ¶

Package

cl-async.

Methods

Reader Method: tcp-socket ((condition streamish-info)) ¶

Writer Method: (setf tcp-socket) ((condition streamish-info)) ¶

Source

streamish.lisp.

Target Slot

streamish.

Generic Function: unref (handle) ¶

Unreference a libuv handle object (uv_unref)

Package

cl-async.

Source

event-loop.lisp.

Methods

Method: unref ((handle notifier)) ¶

Source

notify.lisp.

Method: unref ((handle event)) ¶

Source

event.lisp.

---