std.lang.interface.type-notify — xyz.zcaudate/std.lang 4.1.0

*notify-capture* clj

*notify-override* clj

add-listener clj

(add-listener notify id sink-key f)

adds a listener to the sink

clear-oneshot-sinks clj

(clear-oneshot-sinks {:keys [oneshots sinks]})

clear all registered oneshot sinks

clear-sink clj

(clear-sink {:keys [sinks]} id)

clears a sink

default-notify clj

(default-notify)

gets the default notify server

(notify/default-notify)

default-notify:reset clj

(default-notify:reset)

resets the default notify server

get-oneshot-id clj

(get-oneshot-id {:keys [oneshots]})

registers a oneshot id for the app server

get-sink clj

(get-sink {:keys [sinks]} id)

gets a sink from the notification app server

handle-notify-http clj

(handle-notify-http tx app)

handler for http request

handle-notify-socket clj

(handle-notify-socket socket app)

handler for socket request

has-sink? clj

(has-sink? {:keys [sinks]} id)

checks that sink exists

notify-server clj

(notify-server {:keys [port] :as m})

create and start notify server

notify-server:create clj

(notify-server:create {:keys [http-port socket-port]})

creates notify serve

process-capture clj

(process-capture msg)

processes capture id option

process-message clj

(process-message app input)

processes a message recieved by the notification server

process-print clj

(process-print msg)

processes print id option

remove-listener clj

(remove-listener notify id sink-key)

removes a listener from the sink

remove-oneshot-id clj

(remove-oneshot-id {:keys [oneshots]} id)

removes a oneshot id

start-notify clj

(start-notify app)

starts both servers

(notify/start-notify +server+) => map?

start-notify-http clj

(start-notify-http {:keys [http-port sinks http-instance] :as app})

starts http server

start-notify-socket clj

(start-notify-socket {:keys [socket-port socket-instance sinks] :as app})

starts socket server

stop-notify clj

(stop-notify app)

stops both servers

stop-notify-http clj

(stop-notify-http {:keys [http-instance] :as app})

stops http server

stop-notify-socket clj

(stop-notify-socket {:keys [socket-instance] :as app})

stops socket server

watch-oneshot clj

(watch-oneshot app timeout & [id])

returns a completable future

(notify/watch-oneshot +server+ 10) => (contains [string? h/future?])