The deeds Reference Manual

Next: , Previous: , Up: (dir)   [Contents][Index]

The deeds Reference Manual

This is the deeds Reference Manual, version 1.1.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 04:25:06 2022 GMT+0.

Table of Contents


1 Introduction

About Deeds

Deeds is an Extensible Event Delivery System. It allows for efficient event delivery to multiple handlers with a complex event filtering system.

There are three main components to this system: events, loops, and handlers. Events are certain kinds of messages or data payloads that are to be sent out and processed by other parts in the system. Loops handle the distribution of the events, and handlers then finally do the processing of an event.

There can be multiple independent loops in any application and handlers can be registered on any number of loops simultaneously. However, each event should only be sent out once and only on one loop. If it is necessary to issue an event multiple times or onto multiple loops, it needs to be copied.

The distribution to handlers from the loop follows a strict ordering scheme that is specified on the handlers. Each handler can dictate a list of before and after elements that precisely lay out their position in the issuing sequence. Additionally, handlers can specify a filter and event class that limit the type and kind of events that it will receive.

The loop compiles an efficient, tailored function to issue events to handlers and perform the filtering. This means that even with a significant amount of handlers, issuing an event is still going to be very fast.

Finally there are different types of handlers to give the user more control over the context in which the event handling happens and whether the loop should be blocked during the handler's execution.

How To

Load Deeds through Quicklisp or ASDF:

(ql:quickload :deeds)

By default the system will set up and launch a standard event loop on *standard-event-loop*. You can then add handlers by using define-handler:

(deeds:define-handler (info-handler deeds:info-event) (event message)
  (format T "~&INFO: ~a~%" message))

(deeds:define-handler (smiling-handler deeds:info-event) (event message)
  :filter '(search ":)" message)
  (format T "~&YAY: ~a~%" message))

Now let's issue some events and see what happens:

(deeds:do-issue deeds:info-event :message "Hello!")
(deeds:do-issue deeds:info-event :message "Hey there :)")
(deeds:do-issue deeds:warning-event :message "Help! It's burning!")

By default events have fields for the issue-time, the origin, and whether they've been cancelled. So let's play around with that.

(deeds:define-handler (simple-handler deeds:event) (event)
  (format T "~&Found event: ~a~%" event))

(deeds:define-handler (pre-handler deeds:event) (event)
  :before '(:main)
  :class 'deeds:locally-blocking-handler
  (deeds:cancel event)
  (format T "~&Cancelling!~%"))

The first handler simply prints everything it finds. The second one is special in two ways: first it orders itself before every other normal handler by ordering itself before the main category. Second, it uses a different handler class. The default class is the queued-handler which uses a singular queue in a different thread to process events. This handler on the other hand will not use any threads and instead run directly in the event loop, thus locally blocking it until the handler is done. This allows us to make sure that the event gets cancelled before it reaches anything else:

(deeds:do-issue deeds:event)

As you can see, only the pre-handler is called. If you want to try it out, remove the cancel call and recompile the pre-handler. Then the event should reach both handlers again. Alternatively you can add the :handle-cancelled T option to the simple-handler to override the default behaviour.

Internals

This section documents how the particular standard implementation of the various components works. Some to all of this can be changed by subclassing the existing implementations and overriding the behaviour to suit your needs.

Events

In order to allow for any form of optimisation on the event filtering in the event loop, we need to enforce restrictions on what can happen to an event. The most straightforward restriction is to require immutability of the event slots. However, in some cases it is very much desirable to be able to mutate the slots -- as an example if you'd like to filter the text in a message event. As such, the most appropriate solution is to allow manual overriding of the immutability on a per-slot basis. To achieve this, a custom metaclass event-class along with custom slot classes event-direct-slot-definition event-effective-slot-definition have been created that tend to this behaviour.

The slot classes have an additional field accessible through event-slot-mutable and specifiable through :mutable, which dictates whether the slot is mutable or not. If it is immutable but a writer has been specified on the slot anyway, an immutable-event-slot-has-writer warning is signalled upon class initialisation to warn the user of potentially dangerous behaviour. Similarly, if an attempt is made to actually perform a modification on an immutable slot during any time but the event's initialize-instance time, a continuable error of type immutable-event-slot-modified is signalled. This way it is still possible to perform modifications on immutable slots if absolutely necessary, while the accidental case is prevented.

In order to make defining events easier, a simple wrapper around defclass is provided called define-event. A bunch of standard events are supplied to make the most common event actions easier: message-event, info-event, warning-event, error-event, payload-event, sequence-event, chunked-payload-event, identified-event, stream-event, stream-begin-event, stream-payload-event, and stream-end-event.

Handlers

The primary distinguishing feature of a handler is the question of how it actually invokes the delivery function when an event is issued to the handler from a loop. The most primitive behaviour is to simply call the function directly. This is implemented by the locally-blocking-handler, which in effect will block the issuing loop, but may still be invoked in parallel if multiple loops are involved. The next idea is to spawn a new thread for each event that is issued. This behaviour is implemented by the parallel-handler. However, spawning lots of threads will quickly lead to situations where the threads interleave, and as such it is important that the delivery function takes care to lock and synchronise, which can be taxing on the user. Thus the next idea is to queue events and handle them in a separate thread. This avoids most contention and thrashing issues while still getting the benefit of unblocking the loop. This behaviour is implemented by the queued-handler. Finally there is a variant of the locally-blocking-handler that blocks all loops that have issued an event until their respective event is done. This is implemented by the globally-blocking-handler.

Potentially much more complicated schemes that act differently depending on the issuing loop or the event to be processed could be conceived, but such things are too tied to the actual use-case at hand, and as such are left up to the user to implement. Writing such a handler should not prove very difficult, it is merely a matter of subclassing handler and implementing the appropriate behaviour in issue and handle. The handler can then be used by supplying it to define-handler by the :class option.

Event Loops

Finally the most complicated piece of machinery is the event loop itself. In order to understand the workings, first the lifecycle of an event must be analysed. From a user's perspective this would go as follows: an event instance is created and issued onto a loop. It is then handled by the appropriate handlers in the order as specified by their dependency restrictions. The most primitive way to handle this would be to build a dependency graph of the handlers and traverse them in their topological order, only invoking them when their filter applies to the event.

However, this can become severely limiting when the amount of events and handlers becomes significant. The first optimisation is to separate the loop out into a dedicated thread with an event queue that buffers events. This unblocks the issuing thread and ensures that nothing is held up waiting. The next obvious improvement is to cache the dependency graph walking by generating the proper order of handlers upon handler registration. Finally we can realise that the event handler filters will share a lot of common tests which can be potentially rather costly if repeated too often. It would be good if those could be cached and bundled together to avoid unnecessary retesting.

The default implementation compiled-event-loop in Deeds solves these in the following manner: the unblocking of the issuing thread is achieved through a queue and a background processing thread. The dependency graph is calculated through Tarjan's algorithm and cached as a list. It is recalculated every time a new handler is registered by sort-handlers. Finally, to make the event loop efficient it is treated as a compiled function that is built dynamically whenever necessary through build-event-loop. The mechanism of this is rather complicated.

First, in order to optimise and cache tests the loop is separated into three "phases". The first phase establishes lexical bindings for all tests and performs the type tests on the event object. The second phase performs the actual tests on the event as extracted from the handlers' filters if they are applicable under the current event class. Finally, the handlers are called in their sorted-handlers order if their filter passes. The bulk of this behaviour is done by extract-tests which uses filter-tests to extract all tests from a filter. Tests are simply compared through equal to see if they are the "same". This is a very conservative comparison as several types of tests would return the same result even if their forms are not equal such as for commutative tests. compile-test is used to replace the variable references within a test with event slot accessors as discovered by build-fuzzy-slot-accessor. Finally replace-tests is used to replace the tests in a filter with the corresponding variables that are outputted to cache the tests. This is then all packed together into a lambda form that can then be compiled into a function object.

The optimisations done here are not optimal however. For example, no effort is done to group when forms together in the outputted form when possible. This could save on branching and repeat tests in the resulting form. Similarly, no effort is done to recognise whether the required type tests of the handlers are actually strictly necessary or could be weakened to allow further grouping and conflating of tests. There are potentially many more possible improvements that could be done to make the event loop function even tighter, however the algorithms necessary to achieve this would quickly explode in complexity. For now we settle on this rather primitive approach as being sufficient.

However, you can of course extend the system on your own by subclassing event-loop/sorted-event-loop/compiled-event-loop and implementing the proper methods such as build-event-loop, sort-handlers, register-handler, and deregister-handler.


2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 deeds

Deeds Extensible Event Delivery System

Maintainer

Nicolas Hafner <shinmera@tymoon.eu>

Author

Nicolas Hafner <shinmera@tymoon.eu>

Home Page

https://Shinmera.github.io/deeds/

Source Control

(GIT https://github.com/Shinmera/deeds.git)

Bug Tracker

https://github.com/Shinmera/deeds/issues

License

zlib

Version

1.1.1

Dependencies
  • closer-mop (system).
  • bordeaux-threads (system).
  • lambda-fiddle (system).
  • form-fiddle (system).
Source

deeds.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.1 deeds/deeds.asd

Source

deeds.asd.

Parent Component

deeds (system).

ASDF Systems

deeds.


3.1.2 deeds/package.lisp

Source

deeds.asd.

Parent Component

deeds (system).

Packages

deeds.


3.1.3 deeds/class-slots.lisp

Dependency

package.lisp (file).

Source

deeds.asd.

Parent Component

deeds (system).

Public Interface

3.1.4 deeds/toolkit.lisp

Dependency

class-slots.lisp (file).

Source

deeds.asd.

Parent Component

deeds (system).

Public Interface

with-fuzzy-slot-bindings (macro).

Internals

3.1.5 deeds/origin.lisp

Dependency

toolkit.lisp (file).

Source

deeds.asd.

Parent Component

deeds (system).

Public Interface

3.1.6 deeds/forward-class-definitions.lisp

Dependency

origin.lisp (file).

Source

deeds.asd.

Parent Component

deeds (system).

Public Interface

3.1.7 deeds/event-class.lisp

Dependency

forward-class-definitions.lisp (file).

Source

deeds.asd.

Parent Component

deeds (system).

Public Interface
Internals

check-event-slots (function).


3.1.8 deeds/event.lisp

Dependency

event-class.lisp (file).

Source

deeds.asd.

Parent Component

deeds (system).

Public Interface

3.1.9 deeds/standard-events.lisp

Dependency

event.lisp (file).

Source

deeds.asd.

Parent Component

deeds (system).

Public Interface
Internals

3.1.10 deeds/event-delivery.lisp

Dependency

standard-events.lisp (file).

Source

deeds.asd.

Parent Component

deeds (system).

Public Interface
Internals

3.1.11 deeds/event-loop.lisp

Dependency

event-delivery.lisp (file).

Source

deeds.asd.

Parent Component

deeds (system).

Public Interface
Internals

3.1.12 deeds/handler.lisp

Dependency

event-loop.lisp (file).

Source

deeds.asd.

Parent Component

deeds (system).

Public Interface
Internals

3.1.13 deeds/command.lisp

Dependency

handler.lisp (file).

Source

deeds.asd.

Parent Component

deeds (system).

Public Interface

Previous: , Up: Lisp   [Contents][Index]

3.1.14 deeds/documentation.lisp

Dependency

command.lisp (file).

Source

deeds.asd.

Parent Component

deeds (system).

Internals

4 Packages

Packages are listed by definition order.


Previous: , Up: Packages   [Contents][Index]

4.1 deeds

Source

package.lisp.

Nickname

org.shirakumo.deeds

Use List

common-lisp.

Public Interface
Internals

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Public Interface


Next: , Previous: , Up: Public Interface   [Contents][Index]

5.1.1 Special variables

Special Variable: *origin*

The variable designating the current origin.

The value of this might not be useful or significant for anything, but if at all possible it should denote some kind of identifier for the place where an event was signalled from.

See WITH-ORIGIN

Package

deeds.

Source

origin.lisp.

Special Variable: *standard-event-loop*

The default global instance of a compiled-event-loop.

Package

deeds.

Source

event-loop.lisp.


5.1.2 Macros

Macro: define-cached-slots-class (name direct-superclasses direct-slots &rest options)

Shorthand macro around defclass to define a cached-slots-class.

All this does is wrap the defclass in an EVAL-WHEN and add the metaclass option for cached-slots-class.

See CACHED-SLOTS-CLASS

Package

deeds.

Source

class-slots.lisp.

Macro: define-command (name args &body options-and-body)

Define a command.

This is a combinging macro that does three things:
. Define an event of NAME with the necessary fields from ARGS.
. Define a function of NAME with the given ARGS that issues
an instance of this newly defined event.
. Define a handler of NAME on the NAME event with the given OPTIONS-AND-BODY.

A new option is available just for this macro with the name
:SUPERCLASSES, which allows you to specify the direct-superclasses
to use in the event definition.

The first argument in ARGS must be the name for the event as
required by DEFINE-HANDLER. The rest are arguments to the function
and simultaneously slots on the event class. In order to allow you
to specify slot options, arguments have the following structure:

ARGS ::= SINGLE* [&optional DEFAULTING*] [&rest SINGLE*] [&key DEFAULTING*] SINGLE ::= symbol | (symbol SLOT-ARG*)
DEFAULTING ::= symbol | (symbol value SLOT-ARG*)
SLOT-ARG ::= keyword value

The purpose of defining commands is to allow something akin to a
function definition that can be treated as such for most purposes
while still integrating it with the event system and allowing
extension through that.

Package

deeds.

Source

command.lisp.

Macro: define-event (name direct-superclasses direct-slots &rest options)

Shorthand convenience macro around DEFCLASS to define new event classes.

Pushes the EVENT-CLASS as :METACLASS and EVENT as direct-superclass if it does not already appear somewhere as a transitive superclass.

Package

deeds.

Source

event.lisp.

Macro: define-handler ((name event-type) args &body options-and-body)

Define and register a new event handler on a particular event loop.

This simply expands to a WITH-HANDLER form with a few extra options to make things easier. Most notably, NAME is transformed (quoted) into the :NAME option. If the :SELF option is given, it names the symbol to which the instance of the handler itself is bound, from which it is accessible from within the handler body.

See WITH-HANDLER

Package

deeds.

Source

handler.lisp.

Macro: do-issue (event-type &rest args &key loop &allow-other-keys)

Shorthand macro to allow more convenient issuing of events.

Supports one extra keyword argument that will not be passed along to the MAKE-INSTANCE call: LOOP will instead denote the event-loop to which the event is issued, defaulting to *STANDARD-EVENT-LOOP*.

See *STANDARD-EVENT-LOOP*

Package

deeds.

Source

event-loop.lisp.

Macro: here ()

A macro that tries to figure out the most appropriate identifier for where this is.

Package

deeds.

Source

origin.lisp.

Macro: with-awaiting (response (&key filter timeout loop) setup-form &body body)
Package

deeds.

Source

handler.lisp.

Macro: with-fuzzy-slot-bindings (vars (instance class-ish) &body body)

Establishes a binding context similar to WITH-SLOTS and WITH-ACCESSORS but using the most appropriate way to access a slot, and a fuzzy manner of identifying slots.

Each VAR can either be a list of NAME SLOT-ISH, or simply the SLOT-ISH which will be used as the name as well.

You must pass the class explicitly since we have to be able to analyse the slots of the class during compile time.

See BUILD-FUZZY-SLOT-ACCESSOR

Package

deeds.

Source

toolkit.lisp.

Macro: with-handler (event-type args &body options-and-body)

Convenient macro to construct a handler.

ARGS must be a list of at least one value, which must be a symbol that is bound to the event instance. The rest of the args are slots of the event, bound by WITH-FUZZY-SLOT-BINDINGS. Note that as per the limitation on event-type specifiers arising from FIND-CLASS-SLOT-FOR-COMPOUND, only direct class-name types or compound types consisting of OR and AND are possible for the EVENT-TYPE.

The actual body forms are composed into a lambda form which is passed as the :DELIVERY-FUNCTION argument to MAKE-HANDLER alongside with EVENT-TYPE. It is also wrapped in a WITH-ORIGIN environment where the origin is set to the :NAME option.

See MAKE-HANDLER
See WITH-FUZZY-SLOT-BINDINGS
See WITH-ORIGIN

Package

deeds.

Source

handler.lisp.

Macro: with-immutable-slots-unlocked (() &body body)

Unlocks immutable slots, allowing you to modify them.

This simply automatically calls the CONTINUE restart when an error of type IMMUTABLE-EVENT-SLOT-MODIFIED is signalled.

See EVENT-SLOT

Package

deeds.

Source

event-class.lisp.

Macro: with-one-time-handler (event-type args &body options-and-body)

Constructs a handler that can only handle a single event before being deregistered again.

Defaults the class to ONE-TIME-HANDLER.

See WITH-HANDLER
See ONE-TIME-HANDLER
See DEREGISTER-HANDLER

Package

deeds.

Source

handler.lisp.

Macro: with-origin ((&optional new-origin) &body body)

Binds *ORIGIN* to a new value, which is by default figured out by HERE.

See *ORIGIN*
See HERE

Package

deeds.

Source

origin.lisp.

Macro: with-response (issue response (&key filter timeout issue-loop response-loop) &body body)

A macro to de-asynchronise waiting for a response to an event.

More specifically, this construct allows you to circumvent having to use callbacks and instead allows the handling of an event that is in response to an issued one in the same thread as if it all happened sequentially.

ISSUE ::= event-type | (event-type initarg*)
RESPONSE ::= event-type | (event-type [event-symbol slots*])

In detail the following happens when the block generated by this macro is executed:
. A handler is instantiated with the given response event-type and filter. . The handler is started up.
. The handler’s synchronizer lock is acquired.
. The handler is registered on the given event-loop.
. An event is issued with the event-type and initargs onto the event-loop. . Now the thread waits on the handler’s condition variable.
. Once the thread is reawakened before the timeout it binds the event from the handler and the specified slot variables, then proceeds to evaluate the body.
. As a cleanup, the handler is deregistered and stopped.

The handler itself performs the following steps once it HANDLEs an event: . Acquire the one-time-handler exclusive lock.
. Save the event on its own slot.
. Acquire the synchronizer lock and immediately release it again to ensure that the issuing thread is waiting on the condition variable.
. Notify the condition variable.

See DO-ISSUE
See REGISTER-HANDLER
See DEREGISTER-HANDLER
See WITH-FUZZY-SLOT-BINDINGS
See CONDITION-NOTIFY-HANDLER

Package

deeds.

Source

handler.lisp.


5.1.3 Ordinary functions

Function: broadcast (event-type &rest args &key loop &allow-other-keys)

Shorthand function to allow issuing of an event to multiple loops.

Supports an extra keyword argument that will not be passed along to the MAKE-INSTANCE call: LOOP will instead denote the event-loop/s to which one instance each will be issued, defaulting to *STANDARD-EVENT-LOOP*.

See *STANDARD-EVENT-LOOP*

Package

deeds.

Source

event-loop.lisp.

Function: compute-all-direct-slots (class)

Computes all direct slots of the given class, including those of its superclasses.

This simply traverses the class hierarchy upwards, gathering all
direct-slots instances along the way. If one class along the way
is a CACHED-SLOTS-CLASS, the CLASS-ALL-DIRECT-SLOTS value is used
directly instead of traversing further. This does not apply for
the passed class.

See CACHED-SLOTS-CLASS

Package

deeds.

Source

class-slots.lisp.

Function: make-handler (&rest options &key loop class &allow-other-keys)

Creates a new handler instance and takes care of registering it.

Creating a new handler this way will simply construct the handler object, start it, and register it on the event loop. If a handler with the same name already exists on the event loop, this old handler is stopped and replaced by the new one.

Only the :LOOP and :CLASS options are not passed along to the make-instance call, as they are used by make-handler itself.

See HANDLER
See REGISTER-HANDLER
See QUEUED-HANDLER
See *STANDARD-EVENT-LOOP*
See WITH-HANDLER
See DEFINE-HANDLER
See WITH-ONE-TIME-HANDLER

Package

deeds.

Source

handler.lisp.

Function: test-filter (filter event)

Test the filter against the event.

Note that you must test whether the event is of applicable type as required by the test yourself, since the test form does not contain this information in itself.

The structure of a filter is as follows:

FILTER ::= COMBINATOR | TEST
COMBINATOR ::= (AND TEST*) | (OR TEST*) | (NOT TEST)
TEST ::= (function ARGUMENT*)
ARGUMENT ::= fuzzy-slot-symbol | atom

fuzzy-slot-symbols denote the value of a slot on the event object. The actual slot is figured out per FIND-CLASS-SLOT-FUZZY on the EVENT-TYPE of the handler.

See FIND-CLASS-SLOT-FUZZY

See FILTER

Package

deeds.

Source

event-loop.lisp.


5.1.4 Generic functions

Generic Reader: after (object)

A list of handler names or categories after which this handler should be called.

Package

deeds.

Methods
Reader Method: after ((handler handler))

automatically generated reader method

Source

handler.lisp.

Target Slot

after.

Generic Reader: before (object)

A list of handler names or categories before which this handler should be called.

Package

deeds.

Methods
Reader Method: before ((handler handler))

automatically generated reader method

Source

handler.lisp.

Target Slot

before.

Generic Function: build-event-loop (handlers compiled-event-loop)

Build a lambda form for the event loop delivery function.

The handlers must be in the properly sorted order as returned by SORT-HANDLERS on the same EVENT-LOOP object as is used to call this function.

See COMPILED-EVENT-LOOP

Package

deeds.

Source

event-loop.lisp.

Methods
Method: build-event-loop ((handlers list) (event-loop compiled-event-loop))
Generic Function: cancel (event)

Cancels the event.

An event can be cancelled multiple times though the effect does not change. Once an event has been cancelled it can only be handled by handlers that have HANDLE-CANCELLED set to a non-NIL value.

See CANCELLED
See HANDLE-CANCELLED

Package

deeds.

Source

event.lisp.

Methods
Method: cancel ((event event))
Generic Reader: cancelled (object)

Accessor to whether the event has been cancelled.

See CANCEL

Package

deeds.

Methods
Reader Method: cancelled ((event event))

automatically generated reader method

Source

event.lisp.

Target Slot

cancelled.

Generic Writer: (setf cancelled) (object)
Package

deeds.

Methods
Writer Method: (setf cancelled) ((event event))

automatically generated writer method

Source

event.lisp.

Target Slot

cancelled.

Generic Function: class-all-direct-slots (object)

Finds all direct-slot instances that this class will inherit.

More explicitly, it traverses the superclass tree and gathers all direct-slots it can find.

Package

deeds.

Methods
Method: class-all-direct-slots ((name symbol))
Source

class-slots.lisp.

Method: class-all-direct-slots ((class standard-class))
Source

class-slots.lisp.

Reader Method: class-all-direct-slots ((cached-slots-class cached-slots-class))

automatically generated reader method

Source

class-slots.lisp.

Target Slot

class-all-direct-slots.

Generic Writer: (setf class-all-direct-slots) (object)
Package

deeds.

Methods
Writer Method: (setf class-all-direct-slots) ((cached-slots-class cached-slots-class))

automatically generated writer method

Source

class-slots.lisp.

Target Slot

class-all-direct-slots.

Generic Function: deliver-event-directly (event event-loop)

Performs a primitive, direct delivery of the event on the loop.

This means that handler filters are tested directly without any possible room for optimisation.

See TEST-FILTER

Package

deeds.

Source

event-loop.lisp.

Methods
Method: deliver-event-directly ((event event) (event-loop sorted-event-loop))
Method: deliver-event-directly ((event event) (event-loop event-loop))
Generic Reader: delivery-function (object)

The function that is used to deliver events.

See HANDLE

Package

deeds.

Methods
Reader Method: delivery-function ((event-delivery event-delivery))

automatically generated reader method

Source

event-delivery.lisp.

Target Slot

delivery-function.

Generic Writer: (setf delivery-function) (object)
Package

deeds.

Methods
Writer Method: (setf delivery-function) ((event-delivery event-delivery))

automatically generated writer method

Source

event-delivery.lisp.

Target Slot

delivery-function.

Generic Function: deregister-handler (handler event-loop)

Deregister the given handler so that it no longer receives events from the event-loop.

Deregistering an unregistered handler will not cause an error.
Deregistering a handler might cause the event loop to be recompiled,
which can be a costly operation.

See RECOMPILE-EVENT-LOOP

Package

deeds.

Source

event-loop.lisp.

Methods
Method: deregister-handler :after ((handlers list) (event-loop compiled-event-loop))
Method: deregister-handler :after ((handlers list) (event-loop sorted-event-loop))
Method: deregister-handler ((name symbol) (event-loop event-loop))
Method: deregister-handler ((handlers list) (event-loop event-loop))
Method: deregister-handler :around ((handlers list) (event-loop event-loop))
Method: deregister-handler ((handler handler) (event-loop event-loop))
Generic Function: ensure-handlers-sorted (sorted-event-loop)

Ensures that the handlers are properly sorted on the event-loop

See SORTED-HANDLERS
See SORT-HANDLERS
See SORTED-EVENT-LOOP

Package

deeds.

Source

event-loop.lisp.

Methods
Method: ensure-handlers-sorted ((event-loop sorted-event-loop))
Generic Reader: event-condition-event (condition)

The event that the event condition is about.

Package

deeds.

Methods
Reader Method: event-condition-event ((condition event-condition))
Source

forward-class-definitions.lisp.

Target Slot

event.

Generic Writer: (setf event-condition-event) (condition)
Package

deeds.

Methods
Writer Method: (setf event-condition-event) ((condition event-condition))
Source

forward-class-definitions.lisp.

Target Slot

event.

Generic Reader: event-condition-slot (condition)

The slot that the event condition is about.

Package

deeds.

Methods
Reader Method: event-condition-slot ((condition immutable-event-slot-has-writer))
Source

forward-class-definitions.lisp.

Target Slot

slot.

Reader Method: event-condition-slot ((condition immutable-event-slot-modified))
Source

forward-class-definitions.lisp.

Target Slot

slot.

Generic Writer: (setf event-condition-slot) (condition)
Package

deeds.

Methods
Writer Method: (setf event-condition-slot) ((condition immutable-event-slot-has-writer))
Source

forward-class-definitions.lisp.

Target Slot

slot.

Writer Method: (setf event-condition-slot) ((condition immutable-event-slot-modified))
Source

forward-class-definitions.lisp.

Target Slot

slot.

Generic Reader: event-condition-value (condition)

The value that the event condition is about.

Package

deeds.

Methods
Reader Method: event-condition-value ((condition immutable-event-slot-modified))
Source

forward-class-definitions.lisp.

Target Slot

value.

Generic Writer: (setf event-condition-value) (condition)
Package

deeds.

Methods
Writer Method: (setf event-condition-value) ((condition immutable-event-slot-modified))
Source

forward-class-definitions.lisp.

Target Slot

value.

Generic Reader: event-condition-writers (condition)

The writers that the event condition is about.

Package

deeds.

Methods
Reader Method: event-condition-writers ((condition immutable-event-slot-has-writer))
Source

forward-class-definitions.lisp.

Target Slot

writers.

Generic Writer: (setf event-condition-writers) (condition)
Package

deeds.

Methods
Writer Method: (setf event-condition-writers) ((condition immutable-event-slot-has-writer))
Source

forward-class-definitions.lisp.

Target Slot

writers.

Generic Reader: event-loop (object)
Package

deeds.

Methods
Reader Method: event-loop ((event event))

automatically generated reader method

Source

event.lisp.

Target Slot

event-loop.

Generic Reader: event-loop-condition-event-loop (condition)

The event-loop that the event-loop condition is about.

Package

deeds.

Methods
Reader Method: event-loop-condition-event-loop ((condition event-loop-condition))
Source

forward-class-definitions.lisp.

Target Slot

event-loop.

Generic Writer: (setf event-loop-condition-event-loop) (condition)
Package

deeds.

Methods
Writer Method: (setf event-loop-condition-event-loop) ((condition event-loop-condition))
Source

forward-class-definitions.lisp.

Target Slot

event-loop.

Generic Reader: event-loop-condition-handler (condition)

The handler that the event-loop condition is about.

Package

deeds.

Methods
Reader Method: event-loop-condition-handler ((condition event-loop-handler-dependency-cycle-error))
Source

forward-class-definitions.lisp.

Target Slot

handler.

Generic Writer: (setf event-loop-condition-handler) (condition)
Package

deeds.

Methods
Writer Method: (setf event-loop-condition-handler) ((condition event-loop-handler-dependency-cycle-error))
Source

forward-class-definitions.lisp.

Target Slot

handler.

Generic Reader: event-loop-lock (object)

A lock used to synchronise access to the event-loop slots.

See HANDLERS
See SORTED-HANDLERS
See DELIVERY-FUNCTION

Package

deeds.

Methods
Reader Method: event-loop-lock ((event-loop event-loop))

automatically generated reader method

Source

event-loop.lisp.

Target Slot

event-loop-lock.

Generic Writer: (setf event-loop-lock) (object)
Package

deeds.

Methods
Writer Method: (setf event-loop-lock) ((event-loop event-loop))

automatically generated writer method

Source

event-loop.lisp.

Target Slot

event-loop-lock.

Generic Reader: event-slot-mutable (object)

Accessor to whether the given EVENT-SLOT is mutable or not.

See EVENT-SLOT

Package

deeds.

Methods
Reader Method: event-slot-mutable ((event-slot event-slot))

automatically generated reader method

Source

event-class.lisp.

Target Slot

mutable.

Generic Writer: (setf event-slot-mutable) (object)
Package

deeds.

Methods
Writer Method: (setf event-slot-mutable) ((event-slot event-slot))

automatically generated writer method

Source

event-class.lisp.

Target Slot

mutable.

Generic Reader: event-type (object)

The event-type that the handler accepts.

Package

deeds.

Methods
Reader Method: event-type ((handler handler))

automatically generated reader method

Source

handler.lisp.

Target Slot

event-type.

Generic Reader: filter (object)

The specification of a filter to figure out which events the handler accepts.

See TEST-FILTER

Package

deeds.

Methods
Reader Method: filter ((handler handler))

automatically generated reader method

Source

handler.lisp.

Target Slot

filter.

Generic Function: handle (event event-delivery)

Directly handle the event by sending it to the handlers.

This function bypasses all threading, caching, ordering, and other protective or optimisation constructs of the event delivery itself and processes the event immediately. You should not call this function on your own unless for when you are implementing an event-delivery on your own. In that case you should call this function whenever you are ready to actually process an event and send it out.

By default this simply calls the DELIVERY-FUNCTION of the event-delivery with the given event.

See ISSUE

Package

deeds.

Source

event-delivery.lisp.

Methods
Method: handle ((event event) (handler condition-notify-handler))
Source

handler.lisp.

Method: handle :around ((event event) (handler one-time-handler))
Source

handler.lisp.

Method: handle ((event event) (globally-blocking-handler globally-blocking-handler))
Source

handler.lisp.

Method: handle :around ((event event) (handler handler))
Source

handler.lisp.

Method: handle :around ((event event) (event-loop event-loop))
Source

event-loop.lisp.

Method: handle ((event event) (event-loop event-loop))
Source

event-loop.lisp.

Method: handle ((_ %stop) (event-delivery queued-event-delivery))
Method: handle :after ((event blocking-event) (event-delviery event-delivery))
Method: handle ((event event) (event-delivery event-delivery))
Method: handle :around ((event event) (event-delivery event-delivery))
Generic Reader: handle-cancelled (object)

Accessor to whether the handler will handle events even if they are marked as being cancelled.

Package

deeds.

Methods
Reader Method: handle-cancelled ((handler handler))

automatically generated reader method

Source

handler.lisp.

Target Slot

handle-cancelled.

Generic Function: handler (handler event-loop)

Accesses the named handler from the event-loop, if such exists.

Handlers that do not have a NAME will be named by themselves.

Package

deeds.

Source

event-loop.lisp.

Methods
Method: handler ((handler handler) (event-loop event-loop))
Method: handler ((name symbol) (event-loop event-loop))
Generic Function: (setf handler) (event-loop)
Package

deeds.

Source

event-loop.lisp.

Methods
Method: (setf handler) ((event-loop event-loop))
Generic Reader: handler-condition-handler (condition)

The handler that the handler condition is about.

Package

deeds.

Methods
Reader Method: handler-condition-handler ((condition handler-condition))
Source

forward-class-definitions.lisp.

Target Slot

handler.

Generic Writer: (setf handler-condition-handler) (condition)
Package

deeds.

Methods
Writer Method: (setf handler-condition-handler) ((condition handler-condition))
Source

forward-class-definitions.lisp.

Target Slot

handler.

Generic Reader: handler-condition-thread (condition)

The thread that the handler condition is about.

Package

deeds.

Methods
Reader Method: handler-condition-thread ((condition handler-thread-stop-failed-warning))
Source

forward-class-definitions.lisp.

Target Slot

thread.

Generic Writer: (setf handler-condition-thread) (condition)
Package

deeds.

Methods
Writer Method: (setf handler-condition-thread) ((condition handler-thread-stop-failed-warning))
Source

forward-class-definitions.lisp.

Target Slot

thread.

Generic Reader: handler-lock (object)

Handler lock to lock the access to the internal threads list.

See THREADS

Package

deeds.

Methods
Reader Method: handler-lock ((globally-blocking-handler globally-blocking-handler))

automatically generated reader method

Source

handler.lisp.

Target Slot

handler-lock.

Reader Method: handler-lock ((parallel-handler parallel-handler))

automatically generated reader method

Source

handler.lisp.

Target Slot

handler-lock.

Generic Writer: (setf handler-lock) (object)
Package

deeds.

Methods
Writer Method: (setf handler-lock) ((globally-blocking-handler globally-blocking-handler))

automatically generated writer method

Source

handler.lisp.

Target Slot

handler-lock.

Writer Method: (setf handler-lock) ((parallel-handler parallel-handler))

automatically generated writer method

Source

handler.lisp.

Target Slot

handler-lock.

Generic Reader: handlers (object)

An EQL hash-table of the registered handlers on the event-loop. Be careful when modifying this table, as it is not synchronised.

See EVENT-LOOP-LOCK

Package

deeds.

Methods
Reader Method: handlers ((event-loop event-loop))

automatically generated reader method

Source

event-loop.lisp.

Target Slot

handlers.

Generic Writer: (setf handlers) (object)
Package

deeds.

Methods
Writer Method: (setf handlers) ((event-loop event-loop))

automatically generated writer method

Source

event-loop.lisp.

Target Slot

handlers.

Generic Reader: identifier (object)

The unique identifier of the group the event belongs to.

Package

deeds.

Methods
Reader Method: identifier ((identified-event identified-event))

automatically generated reader method

Source

standard-events.lisp.

Target Slot

identifier.

Generic Reader: index (object)

The position of the event within the sequence.

Package

deeds.

Methods
Reader Method: index ((sequence-event sequence-event))

automatically generated reader method

Source

standard-events.lisp.

Target Slot

index.

Generic Function: issue (event event-delivery)

Issue an event to the delivery so that it is sent out to the handlers.

The exact point in time when the issued event is handled and processed is not specified. However, the order in which events are handled must be the same as the order in which they are issued. An event should only ever be issued once. There is no check made to ensure this, but issuing an event multiple times or on multiple deliveries leads to undefined behaviour. There is also no check made to see whether the event delivery is actually started and ready to accept events. If it is not started, the events might pile up or be dropped on the floor. This is, essentially, undefined behaviour.

Package

deeds.

Source

event-delivery.lisp.

Methods
Method: issue ((blocking-event blocking-event) (parallel-handler parallel-handler))
Source

handler.lisp.

Method: issue ((event event) (parallel-handler parallel-handler))
Source

handler.lisp.

Method: issue :before ((event event) (event-loop event-loop))
Source

event-loop.lisp.

Method: issue :after ((event blocking-event) (event-delivery queued-event-delivery))
Method: issue ((event event) (event-delivery queued-event-delivery))
Method: issue ((event event) (event-delivery event-delivery))
Generic Reader: issue-time (object)

The universal-time at which the event has been ISSUEd to an event-delivery.

See ISSUE.

Package

deeds.

Methods
Reader Method: issue-time ((event event))

automatically generated reader method

Source

event.lisp.

Target Slot

issue-time.

Generic Writer: (setf issue-time) (object)
Package

deeds.

Methods
Writer Method: (setf issue-time) ((event event))

automatically generated writer method

Source

event.lisp.

Target Slot

issue-time.

Generic Reader: loops (object)

Accessor to all the loops the handler is registered on right now.

Package

deeds.

Methods
Reader Method: loops ((handler handler))

automatically generated reader method

Source

handler.lisp.

Target Slot

loops.

Generic Writer: (setf loops) (object)
Package

deeds.

Methods
Writer Method: (setf loops) ((handler handler))

automatically generated writer method

Source

handler.lisp.

Target Slot

loops.

Generic Reader: max-index (object)

The maximum index of the sequence.

Might be NIL if the maximum length of the sequence is not yet known.

Package

deeds.

Methods
Reader Method: max-index ((sequence-event sequence-event))

automatically generated reader method

Source

standard-events.lisp.

Target Slot

max-index.

Generic Reader: message (object)

The message of the message-event.

Package

deeds.

Methods
Reader Method: message ((message-event message-event))

automatically generated reader method

Source

standard-events.lisp.

Target Slot

message.

Generic Reader: name (object)

Returns a symbol describing the name of the object.

Package

deeds.

Methods
Reader Method: name ((handler handler))

automatically generated reader method

Source

handler.lisp.

Target Slot

name.

Generic Reader: origin (object)

Some description of an origin from where the event was issued.

See *ORIGIN*
See WITH-ORIGIN

Package

deeds.

Methods
Reader Method: origin ((event event))

automatically generated reader method

Source

event.lisp.

Target Slot

origin.

Generic Reader: payload (object)

The payload of to be delivered.

Package

deeds.

Methods
Reader Method: payload ((payload-event payload-event))

automatically generated reader method

Source

standard-events.lisp.

Target Slot

payload.

Generic Function: recompile-event-loop (compiled-event-loop)

Cause the event loop to be recompiled.

The event-loop’s handlers must already be ready in their sorted order before calling this function. This operation is potentially very costly as it involves building a potentially very large lambda and successively invoking COMPILE on it. With a large number of registered handlers and a slow compiler, this might take up to the order of seconds to run.

See BUILD-EVENT-LOOP
See ENSURE-HANDLERS-SORTED
See COMPILED-EVENT-LOOP

Package

deeds.

Source

event-loop.lisp.

Methods
Method: recompile-event-loop ((event-loop compiled-event-loop))
Generic Function: register-handler (handler event-loop)

Register the given handler so that it may receive events from the event-loop.

Registering the same handler twice will still result in it receiving events only once, but will not cause an error. Registering a handler might cause the event loop to be recompiled, which can be a costly operation.

See RECOMPILE-EVENT-LOOP

Package

deeds.

Source

event-loop.lisp.

Methods
Method: register-handler :after ((handlers list) (event-loop compiled-event-loop))
Method: register-handler :after ((handlers list) (event-loop sorted-event-loop))
Method: register-handler ((handlers list) (event-loop event-loop))
Method: register-handler :around ((handlers list) (event-loop event-loop))
Method: register-handler ((handler handler) (event-loop event-loop))
Generic Reader: response-event (object)

Accessor to the response event the handler captures.

Package

deeds.

Methods
Reader Method: response-event ((condition-notify-handler condition-notify-handler))

automatically generated reader method

Source

handler.lisp.

Target Slot

response-event.

Generic Writer: (setf response-event) (object)
Package

deeds.

Methods
Writer Method: (setf response-event) ((condition-notify-handler condition-notify-handler))

automatically generated writer method

Source

handler.lisp.

Target Slot

response-event.

Generic Function: running (stuff)

Returns T if the event delivery is able to process events.

Package

deeds.

Methods
Method: running ((event-delivery queued-event-delivery))
Source

event-delivery.lisp.

Method: running ((event-delivery event-delivery))
Source

event-delivery.lisp.

Method: running ((stuff list))
Source

event-delivery.lisp.

Generic Function: sort-handlers (handlers sorted-event-loop)

Sort the given list of handlers into the proper issuing sequence.

The returned list of handlers must be ordered in a way that the
BEFORE and AFTER lists of all handlers are met. If a dependency
cycle is detected, an error of type EVENT-LOOP-HANDLER-DEPENDENCY-CYCLE-ERROR must be signalled.

See SORTED-EVENT-LOOP

Package

deeds.

Source

event-loop.lisp.

Methods
Method: sort-handlers ((handlers list) (event-loop sorted-event-loop))
Method: sort-handlers ((handlers hash-table) (event-loop sorted-event-loop))
Generic Reader: sorted-handlers (object)

A list of the registered handlers in their properly sorted order.

This function might become temporarily out of sync with HANDLERS.

See SORT-HANDLERS
See ENSURE-HANDLERS-SORTED
See SORTED-EVENT-LOOP

Package

deeds.

Methods
Reader Method: sorted-handlers ((sorted-event-loop sorted-event-loop))

automatically generated reader method

Source

event-loop.lisp.

Target Slot

sorted-handlers.

Generic Writer: (setf sorted-handlers) (object)
Package

deeds.

Methods
Writer Method: (setf sorted-handlers) ((sorted-event-loop sorted-event-loop))

automatically generated writer method

Source

event-loop.lisp.

Target Slot

sorted-handlers.

Generic Function: start (event-delivery)

Start the event delivery and make it ready to accept and deliver events.

If the delivery is already running this does nothing.

Package

deeds.

Source

event-delivery.lisp.

Methods
Method: start ((event-delivery queued-event-delivery))
Method: start ((event-delivery event-delivery))
Method: start ((stuff list))
Generic Function: stop (event-delivery)

Stop the event delivery to prevent it from accepting and delivering events.

If there are events that the handler has yet to process, there is no guarantee that they will be processed before the event delivery is stopped.

If the delivery is already stopped this does nothing.

Package

deeds.

Source

event-delivery.lisp.

Methods
Method: stop ((parallel-handler parallel-handler))
Source

handler.lisp.

Method: stop ((event-delivery queued-event-delivery))
Method: stop ((event-delivery event-delivery))
Method: stop ((stuff list))
Generic Reader: threads (object)

The threads of the parallel-handler.

Package

deeds.

Methods
Reader Method: threads ((parallel-handler parallel-handler))

automatically generated reader method

Source

handler.lisp.

Target Slot

threads.

Generic Writer: (setf threads) (object)
Package

deeds.

Methods
Writer Method: (setf threads) ((parallel-handler parallel-handler))

automatically generated writer method

Source

handler.lisp.

Target Slot

threads.


5.1.5 Standalone methods

Method: compute-effective-slot-definition ((class event-class) name direct-slots)
Package

sb-mop.

Source

event-class.lisp.

Method: direct-slot-definition-class ((class event-class) &rest initargs)
Package

sb-mop.

Source

event-class.lisp.

Method: effective-slot-definition-class ((class event-class) &rest initargs)
Package

sb-mop.

Source

event-class.lisp.

Method: initialize-instance :around ((event event) &key)
Source

event.lisp.

Method: initialize-instance :after ((event-loop event-loop) &key)
Source

event-loop.lisp.

Method: initialize-instance :after ((identified-event identified-event) &key)
Source

standard-events.lisp.

Method: initialize-instance :before ((class event-class) &key direct-slots &allow-other-keys)
Source

event-class.lisp.

Method: initialize-instance :after ((class cached-slots-class) &key)
Source

class-slots.lisp.

Method: print-object ((event event) stream)
Source

event.lisp.

Method: print-object ((handler handler) stream)
Source

handler.lisp.

Method: print-object ((handler queued-handler) stream)
Source

handler.lisp.

Method: print-object ((event-delivery event-delivery) stream)
Source

event-delivery.lisp.

Method: reinitialize-instance :before ((class event-class) &key direct-slots &allow-other-keys)
Source

event-class.lisp.

Method: reinitialize-instance :after ((class cached-slots-class) &key)
Source

class-slots.lisp.

Method: (setf slot-value-using-class) :before ((class event-class) event (slotd event-slot))
Package

sb-mop.

Source

event-class.lisp.

Method: validate-superclass ((class event-class) (superclass event-class))
Package

sb-mop.

Source

event-class.lisp.

Method: validate-superclass ((class event-class) (superclass standard-class))
Package

sb-mop.

Source

event-class.lisp.

Method: validate-superclass ((class standard-class) (superclass event-class))
Package

sb-mop.

Source

event-class.lisp.

Method: validate-superclass ((class event-class) superclass)
Package

sb-mop.

Source

event-class.lisp.

Method: validate-superclass ((class cached-slots-class) (superclass cached-slots-class))
Package

sb-mop.

Source

class-slots.lisp.

Method: validate-superclass ((class cached-slots-class) (superclass standard-class))
Package

sb-mop.

Source

class-slots.lisp.

Method: validate-superclass ((class standard-class) (superclass cached-slots-class))
Package

sb-mop.

Source

class-slots.lisp.

Method: validate-superclass ((class cached-slots-class) superclass)
Package

sb-mop.

Source

class-slots.lisp.


5.1.6 Conditions

Condition: event-condition

Condition base class for conditions related to events.

See EVENT-CONDITION-EVENT

Package

deeds.

Source

forward-class-definitions.lisp.

Direct superclasses

condition.

Direct subclasses
Direct methods
Direct slots
Slot: event
Initargs

:event

Readers

event-condition-event.

Writers

(setf event-condition-event).

Condition: event-loop-condition

Condition base class for conditions related to event-loops.

See EVENT-LOOP-CONDITION-EVENT-LOOP

Package

deeds.

Source

forward-class-definitions.lisp.

Direct superclasses

condition.

Direct subclasses

event-loop-handler-dependency-cycle-error.

Direct methods
Direct slots
Slot: event-loop
Initargs

:event-loop

Readers

event-loop-condition-event-loop.

Writers

(setf event-loop-condition-event-loop).

Condition: event-loop-handler-dependency-cycle-error

An error that is signalled whenever a dependency cycle is detected within the handlers.

See EVENT-LOOP-CONDITION
See EVENT-LOOP-CONDITION-HANDLER

Package

deeds.

Source

forward-class-definitions.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: handler
Initargs

:handler

Readers

event-loop-condition-handler.

Writers

(setf event-loop-condition-handler).

Condition: handler-condition

Condition base class for conditions related to handlers.

See HANDLER-CONDITION-HANDLER

Package

deeds.

Source

forward-class-definitions.lisp.

Direct superclasses

condition.

Direct subclasses

handler-thread-stop-failed-warning.

Direct methods
Direct slots
Slot: handler
Initargs

:handler

Readers

handler-condition-handler.

Writers

(setf handler-condition-handler).

Condition: handler-thread-stop-failed-warning

A warning that is signalled whenever a thread of a handler fails to stop.

See HANDLER-CONDITION
See HANDLER-CONDITION-THREAD

Package

deeds.

Source

forward-class-definitions.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: thread
Initargs

:thread

Readers

handler-condition-thread.

Writers

(setf handler-condition-thread).

Condition: immutable-event-slot-has-writer

A warning that is signalled whenever an immutable slot is specified with a writer.

See EVENT-CONDITION
See EVENT-CONDITION-SLOT
See EVENT-CONDITION-WRITERS

Package

deeds.

Source

forward-class-definitions.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: slot
Initargs

:slot

Readers

event-condition-slot.

Writers

(setf event-condition-slot).

Slot: writers
Initargs

:writers

Readers

event-condition-writers.

Writers

(setf event-condition-writers).

Condition: immutable-event-slot-modified

An error that is signalled whenever an attempt is made to modify an immutable slot.

See EVENT-CONDITION
See EVENT-CONDITION-SLOT
See EVENT-CONDITION-VALUE

Package

deeds.

Source

forward-class-definitions.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: slot
Initargs

:slot

Readers

event-condition-slot.

Writers

(setf event-condition-slot).

Slot: value
Initargs

:value

Readers

event-condition-value.

Writers

(setf event-condition-value).


Previous: , Up: Public Interface   [Contents][Index]

5.1.7 Classes

Class: blocking-event

A blocking event.

This event blocks on all handlers it passes through and blocks the issuing thread until it is done being handled. This behaviour is sometimes desired, especially in cases where remote communication is involved and sequential execution on the issuing side must be ensured. This order cannot be guaranteed with standard events, as while the events are issued in order and handled in order by the same handler, they might change order between different handlers.

See EVENT

Package

deeds.

Source

standard-events.lisp.

Direct superclasses

event.

Direct methods
Direct slots
Slot: done
Readers

done.

Writers

(setf done).

Class: cached-slots-class

A metaclass that caches all the direct slot instances available to it.

The cache is renewed on re/initialization of the class.

See CLASS-ALL-DIRECT-SLOTS

Package

deeds.

Source

class-slots.lisp.

Direct superclasses

standard-class.

Direct subclasses

event-class.

Direct methods
Direct slots
Slot: class-all-direct-slots
Readers

class-all-direct-slots.

Writers

(setf class-all-direct-slots).

Class: chunked-payload-event

A payload delivery event for which the payload has been cut up into chunks.

See PAYLOAD-EVENT
See SEQUENCE-EVENT

Package

deeds.

Source

standard-events.lisp.

Direct superclasses
Class: command-event

Event used for commands

See DEFINE-COMMAND

Package

deeds.

Source

command.lisp.

Direct superclasses

event.

Class: compiled-event-loop

An optimised event loop that compiles the issuing function for fast delivery.

Implements a standard queued event loop that respects all other constraints. Supports rudimentary optimisation of the event loop
handler filter tests to speed up delivery and generates a tight
event delivery function that should allow issuing events to
handlers very efficiently.

See SORTED-EVENT-LOOP
See BUILD-EVENT-LOOP
See RECOMPILE-EVENT-LOOP

Package

deeds.

Source

event-loop.lisp.

Direct superclasses

sorted-event-loop.

Direct methods
Class: condition-notify-handler

Handler that notifies a condition variable once it receives its event. Saves the received event in its slot.

See ONE-TIME-HANDLER
See CONDITION-VARIABLE
See ISSUE-SYNCHRONIZER-LOCK
See RESPONSE-EVENT
See WITH-RESPONSE

Package

deeds.

Source

handler.lisp.

Direct superclasses

one-time-handler.

Direct methods
Direct slots
Slot: condition-variable
Initform

(bordeaux-threads:make-condition-variable)

Readers

condition-variable.

Writers

(setf condition-variable).

Slot: issue-synchronizer-lock
Initform

(bordeaux-threads:make-lock)

Readers

issue-synchronizer-lock.

Writers

(setf issue-synchronizer-lock).

Slot: response-event
Readers

response-event.

Writers

(setf response-event).

Class: error-event

Delivers an error message.

See MESSAGE-EVENT

Package

deeds.

Source

standard-events.lisp.

Direct superclasses

message-event.

Class: event

Base class for all events.

Anything that would like to be processed by an event-delivery must inherit from this class.

See ISSUE-TIME
See ORIGIN
See CANCELLED

Package

deeds.

Source

event.lisp.

Direct subclasses
Direct methods
Direct Default Initargs
InitargValue
:origin*origin*
Direct slots
Slot: origin
Initargs

:origin

Readers

origin.

Writers

This slot is read-only.

Slot: event-loop
Readers

event-loop.

Writers

This slot is read-only.

Slot: issue-time
Readers

issue-time.

Writers

(setf issue-time).

Slot: cancelled
Readers

cancelled.

Writers

(setf cancelled).

Class: event-class

Metaclass for events.

Uses the EVENT-SLOT class for slots, to allow specification of im/mutable slots.

See EVENT-SLOT

Package

deeds.

Source

event-class.lisp.

Direct superclasses

cached-slots-class.

Direct methods
Class: event-delivery

A base class for any kind of object that can deliver events.

This class must implement START, STOP, ISSUE, and HANDLE.

See DELIVERY-FUNCTION

Package

deeds.

Source

event-delivery.lisp.

Direct subclasses
Direct methods
Direct Default Initargs
InitargValue
:delivery-function(function print)
Direct slots
Slot: delivery-function
Initargs

:delivery-function

Readers

delivery-function.

Writers

(setf delivery-function).

Class: event-direct-slot-definition

A standard-direct-slot-definition for an event-slot.

Package

deeds.

Source

event-class.lisp.

Direct superclasses
Class: event-effective-slot-definition

A standard-effective-slot-definition for an event-slot.

Package

deeds.

Source

event-class.lisp.

Direct superclasses
Class: event-loop

The base class for an event loop.

This event loop is incredibly crude and should only serve as a basis for either very specific scenarios or to build a new event-loop on top of it. It does not sort the handlers properly nor optimise the delivery in any way but simply tests and calls each handler in whatever order it might find them in at the moment.

On the other hand, de/registering handlers will be very cheap on this handler, as no recompilation or analysis is required.

See QUEUED-EVENT-DELIVERY
See HANDLERS
See EVENT-LOOP-LOCK
See SORTED-EVENT-LOOP
See COMPILED-EVENT-LOOP

Package

deeds.

Source

event-loop.lisp.

Direct superclasses

queued-event-delivery.

Direct subclasses

sorted-event-loop.

Direct methods
Direct Default Initargs
InitargValue
:delivery-functionnil
Direct slots
Slot: handlers
Initform

(make-hash-table :test (quote eql))

Readers

handlers.

Writers

(setf handlers).

Slot: event-loop-lock
Readers

event-loop-lock.

Writers

(setf event-loop-lock).

Class: event-slot

Base class for the event-slot classes.

Contains one extra field (:MUTABLE) that allows specification of
whether the slot is allowed to be mutated through a writer.
If the user attempts to specify a writer (or accessor) on the slot
while :MUTABLE NIL, a warning of type IMMUTABLE-EVENT-SLOT-HAS-WRITER
is signalled. If an attempt is made to write to a slot that has been designated immutable, a continuable error of type IMMUTABLE-EVENT-SLOT-MODIFIED is signalled.

By default slots are immutable.

See EVENT-SLOT-MUTABLE

Package

deeds.

Source

event-class.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: mutable
Initargs

:mutable

Readers

event-slot-mutable.

Writers

(setf event-slot-mutable).

Class: globally-blocking-handler

A handler that globally blocks all issuing threads until it is done.

The difference to LOCALLY-BLOCKING-HANDLER is only apparent in the case where multiple event loops issue to this same handler at the same time, in which case both are blocked until their individual events are done being processed.

See HANDLER
See HANDLER-LOCK

Package

deeds.

Source

handler.lisp.

Direct superclasses

handler.

Direct methods
Direct slots
Slot: handler-lock
Initform

(bordeaux-threads:make-recursive-lock "globally-blocking-handler lock")

Readers

handler-lock.

Writers

(setf handler-lock).

Class: handler

Base class for all handlers to which events can be delivered.

In order for an event to be issued to this, the following criteria should apply to the event. First, the event must pass the type test against the value from the handler’s EVENT-TYPE slot. Note that the event-type can be a compound type. Second, the event must pass the handler’s FILTER test as per TEST-FILTER.

See EVENT-DELIVERY
See NAME
See EVENT-TYPE
See FILTER
See BEFORE
See AFTER
See HANDLE-CANCELLED

Package

deeds.

Source

handler.lisp.

Direct superclasses

event-delivery.

Direct subclasses
Direct methods
Direct Default Initargs
InitargValue
:namenil
:event-type(quote event)
:filternil
:beforenil
:afternil
:handle-cancellednil
Direct slots
Slot: name
Initargs

:name

Readers

name.

Writers

This slot is read-only.

Slot: event-type
Initargs

:event-type

Readers

event-type.

Writers

This slot is read-only.

Slot: filter
Initargs

:filter

Readers

filter.

Writers

This slot is read-only.

Slot: before
Initargs

:before

Readers

before.

Writers

This slot is read-only.

Slot: after
Initargs

:after

Readers

after.

Writers

This slot is read-only.

Slot: handle-cancelled
Initargs

:handle-cancelled

Readers

handle-cancelled.

Writers

This slot is read-only.

Slot: loops
Readers

loops.

Writers

(setf loops).

Class: identified-event

An event that belongs to a certain identified group.

The identifier defaults to the event itself.

See EVENT
See IDENTIFIER

Package

deeds.

Source

standard-events.lisp.

Direct superclasses

event.

Direct subclasses

stream-event.

Direct methods
Direct slots
Slot: identifier
Initargs

:identifier

Readers

identifier.

Writers

This slot is read-only.

Class: info-event

Delivers an informational message.

See MESSAGE-EVENT

Package

deeds.

Source

standard-events.lisp.

Direct superclasses

message-event.

Class: locally-blocking-handler

A handler that handles the event in the issuing thread and thus blocks it.

This is useful for handlers that need to modify the event they receive, as then it is guaranteed that the modification is done before any further handlers can be called with the event.

See HANDLER

Package

deeds.

Source

handler.lisp.

Direct superclasses

handler.

Class: message-event

A simple event merely used to deliver message strings.

See EVENT
See MESSAGE

Package

deeds.

Source

standard-events.lisp.

Direct superclasses

event.

Direct subclasses
Direct methods

message.

Direct Default Initargs
InitargValue
:message(error message required.)
Direct slots
Slot: message
Initargs

:message

Readers

message.

Writers

This slot is read-only.

Class: one-time-handler

A handler that can only be called until it is successful.

If the delivery-function of the handler returns a non-NIL result, the handler immediately deregisters itself from all its loops and stops itself, thus only ever handling one "correct" event.

The return test is done to allow the user more sophisticated testing of the event than is possible through the filter mechanism.

See QUEUED-HANDLER
See WITH-ONE-TIME-HANDLER

Package

deeds.

Source

handler.lisp.

Direct superclasses

handler.

Direct subclasses

condition-notify-handler.

Direct methods

handle.

Class: parallel-handler

A handler that starts a new thread to handle each event that it receives through ISSUE.

Note that if you use this handler you must care for resource locking
yourself. This can potentially be very tricky and inefficient.

See HANDLER
See THREADS
See HANDLER-LOCK

Package

deeds.

Source

handler.lisp.

Direct superclasses

handler.

Direct methods
Direct slots
Slot: threads
Readers

threads.

Writers

(setf threads).

Slot: handler-lock
Initform

(bordeaux-threads:make-recursive-lock "parallel-handler lock")

Readers

handler-lock.

Writers

(setf handler-lock).

Class: payload-event

A simple event used to deliver some kind of data payload.

See EVENT
See PAYLOAD

Package

deeds.

Source

standard-events.lisp.

Direct superclasses

event.

Direct subclasses
Direct methods

payload.

Direct Default Initargs
InitargValue
:payload(error payload required.)
Direct slots
Slot: payload
Initargs

:payload

Readers

payload.

Writers

This slot is read-only.

Class: queued-event-delivery

An event delivery that uses a queue and background thread to deliver events.

See EVENT-DELIVERY

Package

deeds.

Source

event-delivery.lisp.

Direct superclasses

event-delivery.

Direct subclasses
Direct methods
Direct slots
Slot: front-queue
Initform

(make-array 100 :adjustable t :fill-pointer 0)

Readers

front-queue.

Writers

(setf front-queue).

Slot: back-queue
Initform

(make-array 100 :adjustable t :fill-pointer 0)

Readers

back-queue.

Writers

(setf back-queue).

Slot: queue-condition
Initform

(bordeaux-threads:make-condition-variable :name "queue-condition")

Readers

queue-condition.

Writers

This slot is read-only.

Slot: queue-lock
Initform

(bordeaux-threads:make-lock "queue-lock")

Readers

queue-lock.

Writers

This slot is read-only.

Slot: queue-thread
Readers

queue-thread.

Writers

(setf queue-thread).

Class: queued-handler

A handler that uses an event queue and separate thread to process them.

This is the default handler class. Since there is only a single thread per handler, resources on the handler itself should be safe to access. However, you still have to tend after locking of external resources on your own as they might be modified and accessed in any fashion.
Also note that since this is a single, queued handler that any event that takes a very long time will block other events on the handler from being processed. It will not however block the event-loop from which the events are issued.

See HANDLER
See QUEUED-EVENT-DELIVERY

Package

deeds.

Source

handler.lisp.

Direct superclasses
Direct methods

print-object.

Class: sequence-event

An event that is part of a sequence of events.

See EVENT
See INDEX
See MAX-INDEX

Package

deeds.

Source

standard-events.lisp.

Direct superclasses

event.

Direct subclasses

chunked-payload-event.

Direct methods
Direct Default Initargs
InitargValue
:index(error index required.)
:max-indexnil
Direct slots
Slot: index
Initargs

:index

Readers

index.

Writers

This slot is read-only.

Slot: max-index
Initargs

:max-index

Readers

max-index.

Writers

This slot is read-only.

Class: sorted-event-loop

An event loop that respects the sorting order of handlers.

This event loop will always make sure the handlers are in proper order to be called in, but does not perform any further optimisation. As such, this handler should still be reasonably fast to de/register handlers on, but will obviously suffer the deficiencies in issuing due to the lack of optimisation.

See EVENT-LOOP
See SORTED-HANDLERS
See COMPILED-EVENT-LOOP

Package

deeds.

Source

event-loop.lisp.

Direct superclasses

event-loop.

Direct subclasses

compiled-event-loop.

Direct methods
Direct slots
Slot: sorted-handlers
Readers

sorted-handlers.

Writers

(setf sorted-handlers).

Class: stream-begin-event

Stream event to signal the beginning of a stream.

All further stream events that belong to this stream must have the same identifier as this. Events belonging to this stream may appear until a STREAM-END-EVENT has been issued belonging to this stream.

See STREAM-EVENT

Package

deeds.

Source

standard-events.lisp.

Direct superclasses

stream-event.

Class: stream-end-event

Stream event to signal the end of a stream.

See STREAM-EVENT

Package

deeds.

Source

standard-events.lisp.

Direct superclasses

stream-event.

Direct Default Initargs
InitargValue
:identifier(error identifier required.)
Class: stream-event

Base event for stream events.

All stream events that belong to the same stream must have the same identifier. Stream events are insignificant unless they are issued after a STREAM-BEGIN-EVENT of the same identifier and before a STREAM-END-EVENT of the same identifier.

See IDENTIFIED-EVENT

Package

deeds.

Source

standard-events.lisp.

Direct superclasses

identified-event.

Direct subclasses
Class: stream-payload-event

A payload event for a particular stream.

See PAYLOAD-EVENT
See STREAM-EVENT

Package

deeds.

Source

standard-events.lisp.

Direct superclasses
Direct Default Initargs
InitargValue
:identifier(error identifier required.)
Class: warning-event

Delivers a warning message.

See MESSAGE-EVENT

Package

deeds.

Source

standard-events.lisp.

Direct superclasses

message-event.


5.2 Internals


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.1 Macros

Macro: setdocs (&body pairs)

Easily set the documentation.

Package

deeds.

Source

documentation.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.2 Ordinary functions

Function: build-fuzzy-slot-accessor (slot-ish class-ish instance)

Constructs an appropriate accessor form to read/write the given slot-ish.

FIND-CLASS-SLOT-FOR-COMPOUND is used to find an appropriate slot.
If no appropriate slot can be found, an error is signalled.

FIND-SLOT-ACCESSOR is used to detect if an accessor can be
used. If no accessor is found, a SLOT-VALUE form is emitted
instead.

Returns the form and the slot instance.

See FIND-CLASS-SLOT-FUZZY
See FIND-SLOT-ACCESSOR

Package

deeds.

Source

toolkit.lisp.

Function: check-event-slots (class slot-forms)

Checks the given slot-forms to see if any immutable slots have writers.

If such a slot is found, a warning of type IMMUTABLE-EVENT-SLOT-HAS-WRITER is signalled.

Package

deeds.

Source

event-class.lisp.

Function: checkdocs (&optional package)

Check that all functions, classes, and variables have docstrings.

Package

deeds.

Source

documentation.lisp.

Function: compile-lambda (lambda)

Compiles the given LAMBDA form into a function object.

Attempts to muffle all warnings and notes during compilation.

Package

deeds.

Source

toolkit.lisp.

Function: compile-test (test type)
Package

deeds.

Source

event-loop.lisp.

Function: copy-hash-table (old &key test size rehash-size rehash-threshold)

Copies the hash table.

This does not respect potential implementation-dependent hash-table properties.

Package

deeds.

Source

toolkit.lisp.

Function: ensure-list (a &rest elements)
Package

deeds.

Source

toolkit.lisp.

Function: extract-tests (handlers)
Package

deeds.

Source

event-loop.lisp.

Function: filter-tests (filter)
Package

deeds.

Source

event-loop.lisp.

Function: find-class-slot-for-compound (slot-ish compound)

Attempts to find a slot on COMPOUND that matches SLOT-ISH

This allows compound type specifiers for the class, but only for OR and AND. For the purpose of finding the appropriate slot, the semantics of the compound are disregarded. The compound is searched in depth-first order and the first matching slot wins. The actual slot finding for each class is performed by FIND-CLASS-SLOT-FUZZY.

See FIND-CLASS-SLOT-FUZZY

Package

deeds.

Source

toolkit.lisp.

Function: find-class-slot-fuzzy (slot-ish class)

Attempts to find a slot on CLASS that matches SLOT-ISH

A slot is found if SLOT-ISH matches by either slot-name or one
of the readers of the slot through either an EQL or STRING= comparison. If no appropriate slot can be found, NIL is returned instead.

See CLASS-ALL-DIRECT-SLOTS

Package

deeds.

Source

toolkit.lisp.

Function: find-slot-accessor (slot)

Attempts to find an accessor for the given slot.

This works by looping through all writers and seeing if there’s a corresponding reader for it. In the case of a (setf foo) writer it looks for a foo reader.

Package

deeds.

Source

toolkit.lisp.

Function: format-time (universal-time)

Formats UNIVERSAL-TIME into a datestring of the following format: YYYY.MM.DD hh:mm:ss

Package

deeds.

Source

toolkit.lisp.

Function: make-thread (func &optional name)
Package

deeds.

Source

toolkit.lisp.

Function: removef (list &rest remove-properties)

Constructs a copy of LIST, removing the plist properties REMOVE-PROPERTIES.

Package

deeds.

Source

toolkit.lisp.

Function: replace-tests (filter type testmap)
Package

deeds.

Source

event-loop.lisp.

Function: test-gensym (test)
Package

deeds.

Source

event-loop.lisp.

Function: unlist (a)
Package

deeds.

Source

toolkit.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.3 Generic functions

Generic Reader: back-queue (object)
Package

deeds.

Methods
Reader Method: back-queue ((queued-event-delivery queued-event-delivery))

automatically generated reader method

Source

event-delivery.lisp.

Target Slot

back-queue.

Generic Writer: (setf back-queue) (object)
Package

deeds.

Methods
Writer Method: (setf back-queue) ((queued-event-delivery queued-event-delivery))

automatically generated writer method

Source

event-delivery.lisp.

Target Slot

back-queue.

Generic Reader: condition-variable (object)

A condition variable accessor.

Package

deeds.

Methods
Reader Method: condition-variable ((condition-notify-handler condition-notify-handler))

automatically generated reader method

Source

handler.lisp.

Target Slot

condition-variable.

Generic Writer: (setf condition-variable) (object)
Package

deeds.

Methods
Writer Method: (setf condition-variable) ((condition-notify-handler condition-notify-handler))

automatically generated writer method

Source

handler.lisp.

Target Slot

condition-variable.

Generic Reader: done (object)
Package

deeds.

Methods
Reader Method: done ((blocking-event blocking-event))

automatically generated reader method

Source

standard-events.lisp.

Target Slot

done.

Generic Writer: (setf done) (object)
Package

deeds.

Methods
Writer Method: (setf done) ((blocking-event blocking-event))

automatically generated writer method

Source

standard-events.lisp.

Target Slot

done.

Generic Reader: front-queue (object)
Package

deeds.

Methods
Reader Method: front-queue ((queued-event-delivery queued-event-delivery))

automatically generated reader method

Source

event-delivery.lisp.

Target Slot

front-queue.

Generic Writer: (setf front-queue) (object)
Package

deeds.

Methods
Writer Method: (setf front-queue) ((queued-event-delivery queued-event-delivery))

automatically generated writer method

Source

event-delivery.lisp.

Target Slot

front-queue.

Generic Reader: issue-synchronizer-lock (object)

Accessor to the lock used to synchronise the handler with the issuer.

Package

deeds.

Methods
Reader Method: issue-synchronizer-lock ((condition-notify-handler condition-notify-handler))

automatically generated reader method

Source

handler.lisp.

Target Slot

issue-synchronizer-lock.

Generic Writer: (setf issue-synchronizer-lock) (object)
Package

deeds.

Methods
Writer Method: (setf issue-synchronizer-lock) ((condition-notify-handler condition-notify-handler))

automatically generated writer method

Source

handler.lisp.

Target Slot

issue-synchronizer-lock.

Generic Function: process-delivery-queue (event-delivery)
Package

deeds.

Methods
Method: process-delivery-queue ((event-delivery queued-event-delivery))
Source

event-delivery.lisp.

Generic Reader: queue-condition (object)
Package

deeds.

Methods
Reader Method: queue-condition ((queued-event-delivery queued-event-delivery))

automatically generated reader method

Source

event-delivery.lisp.

Target Slot

queue-condition.

Generic Reader: queue-lock (object)
Package

deeds.

Methods
Reader Method: queue-lock ((queued-event-delivery queued-event-delivery))

automatically generated reader method

Source

event-delivery.lisp.

Target Slot

queue-lock.

Generic Reader: queue-thread (object)
Package

deeds.

Methods
Reader Method: queue-thread ((queued-event-delivery queued-event-delivery))

automatically generated reader method

Source

event-delivery.lisp.

Target Slot

queue-thread.

Generic Writer: (setf queue-thread) (object)
Package

deeds.

Methods
Writer Method: (setf queue-thread) ((queued-event-delivery queued-event-delivery))

automatically generated writer method

Source

event-delivery.lisp.

Target Slot

queue-thread.


Previous: , Up: Internals   [Contents][Index]

5.2.4 Classes

Class: %stop
Package

deeds.

Source

event-delivery.lisp.

Direct methods

handle.


Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts


Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   Q   R   S   T   U   V   W  
Index Entry  Section

(
(setf back-queue): Private generic functions
(setf back-queue): Private generic functions
(setf cancelled): Public generic functions
(setf cancelled): Public generic functions
(setf class-all-direct-slots): Public generic functions
(setf class-all-direct-slots): Public generic functions
(setf condition-variable): Private generic functions
(setf condition-variable): Private generic functions
(setf delivery-function): Public generic functions
(setf delivery-function): Public generic functions
(setf done): Private generic functions
(setf done): Private generic functions
(setf event-condition-event): Public generic functions
(setf event-condition-event): Public generic functions
(setf event-condition-slot): Public generic functions
(setf event-condition-slot): Public generic functions
(setf event-condition-slot): Public generic functions
(setf event-condition-value): Public generic functions
(setf event-condition-value): Public generic functions
(setf event-condition-writers): Public generic functions
(setf event-condition-writers): Public generic functions
(setf event-loop-condition-event-loop): Public generic functions
(setf event-loop-condition-event-loop): Public generic functions
(setf event-loop-condition-handler): Public generic functions
(setf event-loop-condition-handler): Public generic functions
(setf event-loop-lock): Public generic functions
(setf event-loop-lock): Public generic functions
(setf event-slot-mutable): Public generic functions
(setf event-slot-mutable): Public generic functions
(setf front-queue): Private generic functions
(setf front-queue): Private generic functions
(setf handler): Public generic functions
(setf handler): Public generic functions
(setf handler-condition-handler): Public generic functions
(setf handler-condition-handler): Public generic functions
(setf handler-condition-thread): Public generic functions
(setf handler-condition-thread): Public generic functions
(setf handler-lock): Public generic functions
(setf handler-lock): Public generic functions
(setf handler-lock): Public generic functions
(setf handlers): Public generic functions
(setf handlers): Public generic functions
(setf issue-synchronizer-lock): Private generic functions
(setf issue-synchronizer-lock): Private generic functions
(setf issue-time): Public generic functions
(setf issue-time): Public generic functions
(setf loops): Public generic functions
(setf loops): Public generic functions
(setf queue-thread): Private generic functions
(setf queue-thread): Private generic functions
(setf response-event): Public generic functions
(setf response-event): Public generic functions
(setf slot-value-using-class): Public standalone methods
(setf sorted-handlers): Public generic functions
(setf sorted-handlers): Public generic functions
(setf threads): Public generic functions
(setf threads): Public generic functions

A
after: Public generic functions
after: Public generic functions

B
back-queue: Private generic functions
back-queue: Private generic functions
before: Public generic functions
before: Public generic functions
broadcast: Public ordinary functions
build-event-loop: Public generic functions
build-event-loop: Public generic functions
build-fuzzy-slot-accessor: Private ordinary functions

C
cancel: Public generic functions
cancel: Public generic functions
cancelled: Public generic functions
cancelled: Public generic functions
check-event-slots: Private ordinary functions
checkdocs: Private ordinary functions
class-all-direct-slots: Public generic functions
class-all-direct-slots: Public generic functions
class-all-direct-slots: Public generic functions
class-all-direct-slots: Public generic functions
compile-lambda: Private ordinary functions
compile-test: Private ordinary functions
compute-all-direct-slots: Public ordinary functions
compute-effective-slot-definition: Public standalone methods
condition-variable: Private generic functions
condition-variable: Private generic functions
copy-hash-table: Private ordinary functions

D
define-cached-slots-class: Public macros
define-command: Public macros
define-event: Public macros
define-handler: Public macros
deliver-event-directly: Public generic functions
deliver-event-directly: Public generic functions
deliver-event-directly: Public generic functions
delivery-function: Public generic functions
delivery-function: Public generic functions
deregister-handler: Public generic functions
deregister-handler: Public generic functions
deregister-handler: Public generic functions
deregister-handler: Public generic functions
deregister-handler: Public generic functions
deregister-handler: Public generic functions
deregister-handler: Public generic functions
direct-slot-definition-class: Public standalone methods
do-issue: Public macros
done: Private generic functions
done: Private generic functions

E
effective-slot-definition-class: Public standalone methods
ensure-handlers-sorted: Public generic functions
ensure-handlers-sorted: Public generic functions
ensure-list: Private ordinary functions
event-condition-event: Public generic functions
event-condition-event: Public generic functions
event-condition-slot: Public generic functions
event-condition-slot: Public generic functions
event-condition-slot: Public generic functions
event-condition-value: Public generic functions
event-condition-value: Public generic functions
event-condition-writers: Public generic functions
event-condition-writers: Public generic functions
event-loop: Public generic functions
event-loop: Public generic functions
event-loop-condition-event-loop: Public generic functions
event-loop-condition-event-loop: Public generic functions
event-loop-condition-handler: Public generic functions
event-loop-condition-handler: Public generic functions
event-loop-lock: Public generic functions
event-loop-lock: Public generic functions
event-slot-mutable: Public generic functions
event-slot-mutable: Public generic functions
event-type: Public generic functions
event-type: Public generic functions
extract-tests: Private ordinary functions

F
filter: Public generic functions
filter: Public generic functions
filter-tests: Private ordinary functions
find-class-slot-for-compound: Private ordinary functions
find-class-slot-fuzzy: Private ordinary functions
find-slot-accessor: Private ordinary functions
format-time: Private ordinary functions
front-queue: Private generic functions
front-queue: Private generic functions
Function, broadcast: Public ordinary functions
Function, build-fuzzy-slot-accessor: Private ordinary functions
Function, check-event-slots: Private ordinary functions
Function, checkdocs: Private ordinary functions
Function, compile-lambda: Private ordinary functions
Function, compile-test: Private ordinary functions
Function, compute-all-direct-slots: Public ordinary functions
Function, copy-hash-table: Private ordinary functions
Function, ensure-list: Private ordinary functions
Function, extract-tests: Private ordinary functions
Function, filter-tests: Private ordinary functions
Function, find-class-slot-for-compound: Private ordinary functions
Function, find-class-slot-fuzzy: Private ordinary functions
Function, find-slot-accessor: Private ordinary functions
Function, format-time: Private ordinary functions
Function, make-handler: Public ordinary functions
Function, make-thread: Private ordinary functions
Function, removef: Private ordinary functions
Function, replace-tests: Private ordinary functions
Function, test-filter: Public ordinary functions
Function, test-gensym: Private ordinary functions
Function, unlist: Private ordinary functions

G
Generic Function, (setf back-queue): Private generic functions
Generic Function, (setf cancelled): Public generic functions
Generic Function, (setf class-all-direct-slots): Public generic functions
Generic Function, (setf condition-variable): Private generic functions
Generic Function, (setf delivery-function): Public generic functions
Generic Function, (setf done): Private generic functions
Generic Function, (setf event-condition-event): Public generic functions
Generic Function, (setf event-condition-slot): Public generic functions
Generic Function, (setf event-condition-value): Public generic functions
Generic Function, (setf event-condition-writers): Public generic functions
Generic Function, (setf event-loop-condition-event-loop): Public generic functions
Generic Function, (setf event-loop-condition-handler): Public generic functions
Generic Function, (setf event-loop-lock): Public generic functions
Generic Function, (setf event-slot-mutable): Public generic functions
Generic Function, (setf front-queue): Private generic functions
Generic Function, (setf handler): Public generic functions
Generic Function, (setf handler-condition-handler): Public generic functions
Generic Function, (setf handler-condition-thread): Public generic functions
Generic Function, (setf handler-lock): Public generic functions
Generic Function, (setf handlers): Public generic functions
Generic Function, (setf issue-synchronizer-lock): Private generic functions
Generic Function, (setf issue-time): Public generic functions
Generic Function, (setf loops): Public generic functions
Generic Function, (setf queue-thread): Private generic functions
Generic Function, (setf response-event): Public generic functions
Generic Function, (setf sorted-handlers): Public generic functions
Generic Function, (setf threads): Public generic functions
Generic Function, after: Public generic functions
Generic Function, back-queue: Private generic functions
Generic Function, before: Public generic functions
Generic Function, build-event-loop: Public generic functions
Generic Function, cancel: Public generic functions
Generic Function, cancelled: Public generic functions
Generic Function, class-all-direct-slots: Public generic functions
Generic Function, condition-variable: Private generic functions
Generic Function, deliver-event-directly: Public generic functions
Generic Function, delivery-function: Public generic functions
Generic Function, deregister-handler: Public generic functions
Generic Function, done: Private generic functions
Generic Function, ensure-handlers-sorted: Public generic functions
Generic Function, event-condition-event: Public generic functions
Generic Function, event-condition-slot: Public generic functions
Generic Function, event-condition-value: Public generic functions
Generic Function, event-condition-writers: Public generic functions
Generic Function, event-loop: Public generic functions
Generic Function, event-loop-condition-event-loop: Public generic functions
Generic Function, event-loop-condition-handler: Public generic functions
Generic Function, event-loop-lock: Public generic functions
Generic Function, event-slot-mutable: Public generic functions
Generic Function, event-type: Public generic functions
Generic Function, filter: Public generic functions
Generic Function, front-queue: Private generic functions
Generic Function, handle: Public generic functions
Generic Function, handle-cancelled: Public generic functions
Generic Function, handler: Public generic functions
Generic Function, handler-condition-handler: Public generic functions
Generic Function, handler-condition-thread: Public generic functions
Generic Function, handler-lock: Public generic functions
Generic Function, handlers: Public generic functions
Generic Function, identifier: Public generic functions
Generic Function, index: Public generic functions
Generic Function, issue: Public generic functions
Generic Function, issue-synchronizer-lock: Private generic functions
Generic Function, issue-time: Public generic functions
Generic Function, loops: Public generic functions
Generic Function, max-index: Public generic functions
Generic Function, message: Public generic functions
Generic Function, name: Public generic functions
Generic Function, origin: Public generic functions
Generic Function, payload: Public generic functions
Generic Function, process-delivery-queue: Private generic functions
Generic Function, queue-condition: Private generic functions
Generic Function, queue-lock: Private generic functions
Generic Function, queue-thread: Private generic functions
Generic Function, recompile-event-loop: Public generic functions
Generic Function, register-handler: Public generic functions
Generic Function, response-event: Public generic functions
Generic Function, running: Public generic functions
Generic Function, sort-handlers: Public generic functions
Generic Function, sorted-handlers: Public generic functions
Generic Function, start: Public generic functions
Generic Function, stop: Public generic functions
Generic Function, threads: Public generic functions

H
handle: Public generic functions
handle: Public generic functions
handle: Public generic functions
handle: Public generic functions
handle: Public generic functions
handle: Public generic functions
handle: Public generic functions
handle: Public generic functions
handle: Public generic functions
handle: Public generic functions
handle: Public generic functions
handle-cancelled: Public generic functions
handle-cancelled: Public generic functions
handler: Public generic functions
handler: Public generic functions
handler: Public generic functions
handler-condition-handler: Public generic functions
handler-condition-handler: Public generic functions
handler-condition-thread: Public generic functions
handler-condition-thread: Public generic functions
handler-lock: Public generic functions
handler-lock: Public generic functions
handler-lock: Public generic functions
handlers: Public generic functions
handlers: Public generic functions
here: Public macros

I
identifier: Public generic functions
identifier: Public generic functions
index: Public generic functions
index: Public generic functions
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
issue: Public generic functions
issue: Public generic functions
issue: Public generic functions
issue: Public generic functions
issue: Public generic functions
issue: Public generic functions
issue: Public generic functions
issue-synchronizer-lock: Private generic functions
issue-synchronizer-lock: Private generic functions
issue-time: Public generic functions
issue-time: Public generic functions

L
loops: Public generic functions
loops: Public generic functions

M
Macro, define-cached-slots-class: Public macros
Macro, define-command: Public macros
Macro, define-event: Public macros
Macro, define-handler: Public macros
Macro, do-issue: Public macros
Macro, here: Public macros
Macro, setdocs: Private macros
Macro, with-awaiting: Public macros
Macro, with-fuzzy-slot-bindings: Public macros
Macro, with-handler: Public macros
Macro, with-immutable-slots-unlocked: Public macros
Macro, with-one-time-handler: Public macros
Macro, with-origin: Public macros
Macro, with-response: Public macros
make-handler: Public ordinary functions
make-thread: Private ordinary functions
max-index: Public generic functions
max-index: Public generic functions
message: Public generic functions
message: Public generic functions
Method, (setf back-queue): Private generic functions
Method, (setf cancelled): Public generic functions
Method, (setf class-all-direct-slots): Public generic functions
Method, (setf condition-variable): Private generic functions
Method, (setf delivery-function): Public generic functions
Method, (setf done): Private generic functions
Method, (setf event-condition-event): Public generic functions
Method, (setf event-condition-slot): Public generic functions
Method, (setf event-condition-slot): Public generic functions
Method, (setf event-condition-value): Public generic functions
Method, (setf event-condition-writers): Public generic functions
Method, (setf event-loop-condition-event-loop): Public generic functions
Method, (setf event-loop-condition-handler): Public generic functions
Method, (setf event-loop-lock): Public generic functions
Method, (setf event-slot-mutable): Public generic functions
Method, (setf front-queue): Private generic functions
Method, (setf handler): Public generic functions
Method, (setf handler-condition-handler): Public generic functions
Method, (setf handler-condition-thread): Public generic functions
Method, (setf handler-lock): Public generic functions
Method, (setf handler-lock): Public generic functions
Method, (setf handlers): Public generic functions
Method, (setf issue-synchronizer-lock): Private generic functions
Method, (setf issue-time): Public generic functions
Method, (setf loops): Public generic functions
Method, (setf queue-thread): Private generic functions
Method, (setf response-event): Public generic functions
Method, (setf slot-value-using-class): Public standalone methods
Method, (setf sorted-handlers): Public generic functions
Method, (setf threads): Public generic functions
Method, after: Public generic functions
Method, back-queue: Private generic functions
Method, before: Public generic functions
Method, build-event-loop: Public generic functions
Method, cancel: Public generic functions
Method, cancelled: Public generic functions
Method, class-all-direct-slots: Public generic functions
Method, class-all-direct-slots: Public generic functions
Method, class-all-direct-slots: Public generic functions
Method, compute-effective-slot-definition: Public standalone methods
Method, condition-variable: Private generic functions
Method, deliver-event-directly: Public generic functions
Method, deliver-event-directly: Public generic functions
Method, delivery-function: Public generic functions
Method, deregister-handler: Public generic functions
Method, deregister-handler: Public generic functions
Method, deregister-handler: Public generic functions
Method, deregister-handler: Public generic functions
Method, deregister-handler: Public generic functions
Method, deregister-handler: Public generic functions
Method, direct-slot-definition-class: Public standalone methods
Method, done: Private generic functions
Method, effective-slot-definition-class: Public standalone methods
Method, ensure-handlers-sorted: Public generic functions
Method, event-condition-event: Public generic functions
Method, event-condition-slot: Public generic functions
Method, event-condition-slot: Public generic functions
Method, event-condition-value: Public generic functions
Method, event-condition-writers: Public generic functions
Method, event-loop: Public generic functions
Method, event-loop-condition-event-loop: Public generic functions
Method, event-loop-condition-handler: Public generic functions
Method, event-loop-lock: Public generic functions
Method, event-slot-mutable: Public generic functions
Method, event-type: Public generic functions
Method, filter: Public generic functions
Method, front-queue: Private generic functions
Method, handle: Public generic functions
Method, handle: Public generic functions
Method, handle: Public generic functions
Method, handle: Public generic functions
Method, handle: Public generic functions
Method, handle: Public generic functions
Method, handle: Public generic functions
Method, handle: Public generic functions
Method, handle: Public generic functions
Method, handle: Public generic functions
Method, handle-cancelled: Public generic functions
Method, handler: Public generic functions
Method, handler: Public generic functions
Method, handler-condition-handler: Public generic functions
Method, handler-condition-thread: Public generic functions
Method, handler-lock: Public generic functions
Method, handler-lock: Public generic functions
Method, handlers: Public generic functions
Method, identifier: Public generic functions
Method, index: Public generic functions
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, issue: Public generic functions
Method, issue: Public generic functions
Method, issue: Public generic functions
Method, issue: Public generic functions
Method, issue: Public generic functions
Method, issue: Public generic functions
Method, issue-synchronizer-lock: Private generic functions
Method, issue-time: Public generic functions
Method, loops: Public generic functions
Method, max-index: Public generic functions
Method, message: Public generic functions
Method, name: Public generic functions
Method, origin: Public generic functions
Method, payload: Public generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, process-delivery-queue: Private generic functions
Method, queue-condition: Private generic functions
Method, queue-lock: Private generic functions
Method, queue-thread: Private generic functions
Method, recompile-event-loop: Public generic functions
Method, register-handler: Public generic functions
Method, register-handler: Public generic functions
Method, register-handler: Public generic functions
Method, register-handler: Public generic functions
Method, register-handler: Public generic functions
Method, reinitialize-instance: Public standalone methods
Method, reinitialize-instance: Public standalone methods
Method, response-event: Public generic functions
Method, running: Public generic functions
Method, running: Public generic functions
Method, running: Public generic functions
Method, sort-handlers: Public generic functions
Method, sort-handlers: Public generic functions
Method, sorted-handlers: Public generic functions
Method, start: Public generic functions
Method, start: Public generic functions
Method, start: Public generic functions
Method, stop: Public generic functions
Method, stop: Public generic functions
Method, stop: Public generic functions
Method, stop: Public generic functions
Method, threads: Public generic functions
Method, validate-superclass: Public standalone methods
Method, validate-superclass: Public standalone methods
Method, validate-superclass: Public standalone methods
Method, validate-superclass: Public standalone methods
Method, validate-superclass: Public standalone methods
Method, validate-superclass: Public standalone methods
Method, validate-superclass: Public standalone methods
Method, validate-superclass: Public standalone methods

N
name: Public generic functions
name: Public generic functions

O
origin: Public generic functions
origin: Public generic functions

P
payload: Public generic functions
payload: Public generic functions
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
process-delivery-queue: Private generic functions
process-delivery-queue: Private generic functions

Q
queue-condition: Private generic functions
queue-condition: Private generic functions
queue-lock: Private generic functions
queue-lock: Private generic functions
queue-thread: Private generic functions
queue-thread: Private generic functions

R
recompile-event-loop: Public generic functions
recompile-event-loop: Public generic functions
register-handler: Public generic functions
register-handler: Public generic functions
register-handler: Public generic functions
register-handler: Public generic functions
register-handler: Public generic functions
register-handler: Public generic functions
reinitialize-instance: Public standalone methods
reinitialize-instance: Public standalone methods
removef: Private ordinary functions
replace-tests: Private ordinary functions
response-event: Public generic functions
response-event: Public generic functions
running: Public generic functions
running: Public generic functions
running: Public generic functions
running: Public generic functions

S
setdocs: Private macros
sort-handlers: Public generic functions
sort-handlers: Public generic functions
sort-handlers: Public generic functions
sorted-handlers: Public generic functions
sorted-handlers: Public generic functions
start: Public generic functions
start: Public generic functions
start: Public generic functions
start: Public generic functions
stop: Public generic functions
stop: Public generic functions
stop: Public generic functions
stop: Public generic functions
stop: Public generic functions

T
test-filter: Public ordinary functions
test-gensym: Private ordinary functions
threads: Public generic functions
threads: Public generic functions

U
unlist: Private ordinary functions

V
validate-superclass: Public standalone methods
validate-superclass: Public standalone methods
validate-superclass: Public standalone methods
validate-superclass: Public standalone methods
validate-superclass: Public standalone methods
validate-superclass: Public standalone methods
validate-superclass: Public standalone methods
validate-superclass: Public standalone methods

W
with-awaiting: Public macros
with-fuzzy-slot-bindings: Public macros
with-handler: Public macros
with-immutable-slots-unlocked: Public macros
with-one-time-handler: Public macros
with-origin: Public macros
with-response: Public macros

Jump to:   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   Q   R   S   T   U   V   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *  
A   B   C   D   E   F   H   I   L   M   N   O   P   Q   R   S   T   V   W  
Index Entry  Section

*
*origin*: Public special variables
*standard-event-loop*: Public special variables

A
after: Public classes

B
back-queue: Public classes
before: Public classes

C
cancelled: Public classes
class-all-direct-slots: Public classes
condition-variable: Public classes

D
delivery-function: Public classes
done: Public classes

E
event: Public conditions
event-loop: Public conditions
event-loop: Public classes
event-loop-lock: Public classes
event-type: Public classes

F
filter: Public classes
front-queue: Public classes

H
handle-cancelled: Public classes
handler: Public conditions
handler: Public conditions
handler-lock: Public classes
handler-lock: Public classes
handlers: Public classes

I
identifier: Public classes
index: Public classes
issue-synchronizer-lock: Public classes
issue-time: Public classes

L
loops: Public classes

M
max-index: Public classes
message: Public classes
mutable: Public classes

N
name: Public classes

O
origin: Public classes

P
payload: Public classes

Q
queue-condition: Public classes
queue-lock: Public classes
queue-thread: Public classes

R
response-event: Public classes

S
slot: Public conditions
slot: Public conditions
Slot, after: Public classes
Slot, back-queue: Public classes
Slot, before: Public classes
Slot, cancelled: Public classes
Slot, class-all-direct-slots: Public classes
Slot, condition-variable: Public classes
Slot, delivery-function: Public classes
Slot, done: Public classes
Slot, event: Public conditions
Slot, event-loop: Public conditions
Slot, event-loop: Public classes
Slot, event-loop-lock: Public classes
Slot, event-type: Public classes
Slot, filter: Public classes
Slot, front-queue: Public classes
Slot, handle-cancelled: Public classes
Slot, handler: Public conditions
Slot, handler: Public conditions
Slot, handler-lock: Public classes
Slot, handler-lock: Public classes
Slot, handlers: Public classes
Slot, identifier: Public classes
Slot, index: Public classes
Slot, issue-synchronizer-lock: Public classes
Slot, issue-time: Public classes
Slot, loops: Public classes
Slot, max-index: Public classes
Slot, message: Public classes
Slot, mutable: Public classes
Slot, name: Public classes
Slot, origin: Public classes
Slot, payload: Public classes
Slot, queue-condition: Public classes
Slot, queue-lock: Public classes
Slot, queue-thread: Public classes
Slot, response-event: Public classes
Slot, slot: Public conditions
Slot, slot: Public conditions
Slot, sorted-handlers: Public classes
Slot, thread: Public conditions
Slot, threads: Public classes
Slot, value: Public conditions
Slot, writers: Public conditions
sorted-handlers: Public classes
Special Variable, *origin*: Public special variables
Special Variable, *standard-event-loop*: Public special variables

T
thread: Public conditions
threads: Public classes

V
value: Public conditions

W
writers: Public conditions

Jump to:   *  
A   B   C   D   E   F   H   I   L   M   N   O   P   Q   R   S   T   V   W  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   %  
B   C   D   E   F   G   H   I   L   M   O   P   Q   S   T   W  
Index Entry  Section

%
%stop: Private classes

B
blocking-event: Public classes

C
cached-slots-class: Public classes
chunked-payload-event: Public classes
Class, %stop: Private classes
Class, blocking-event: Public classes
Class, cached-slots-class: Public classes
Class, chunked-payload-event: Public classes
Class, command-event: Public classes
Class, compiled-event-loop: Public classes
Class, condition-notify-handler: Public classes
Class, error-event: Public classes
Class, event: Public classes
Class, event-class: Public classes
Class, event-delivery: Public classes
Class, event-direct-slot-definition: Public classes
Class, event-effective-slot-definition: Public classes
Class, event-loop: Public classes
Class, event-slot: Public classes
Class, globally-blocking-handler: Public classes
Class, handler: Public classes
Class, identified-event: Public classes
Class, info-event: Public classes
Class, locally-blocking-handler: Public classes
Class, message-event: Public classes
Class, one-time-handler: Public classes
Class, parallel-handler: Public classes
Class, payload-event: Public classes
Class, queued-event-delivery: Public classes
Class, queued-handler: Public classes
Class, sequence-event: Public classes
Class, sorted-event-loop: Public classes
Class, stream-begin-event: Public classes
Class, stream-end-event: Public classes
Class, stream-event: Public classes
Class, stream-payload-event: Public classes
Class, warning-event: Public classes
class-slots.lisp: The deeds/class-slots․lisp file
command-event: Public classes
command.lisp: The deeds/command․lisp file
compiled-event-loop: Public classes
Condition, event-condition: Public conditions
Condition, event-loop-condition: Public conditions
Condition, event-loop-handler-dependency-cycle-error: Public conditions
Condition, handler-condition: Public conditions
Condition, handler-thread-stop-failed-warning: Public conditions
Condition, immutable-event-slot-has-writer: Public conditions
Condition, immutable-event-slot-modified: Public conditions
condition-notify-handler: Public classes

D
deeds: The deeds system
deeds: The deeds package
deeds.asd: The deeds/deeds․asd file
documentation.lisp: The deeds/documentation․lisp file

E
error-event: Public classes
event: Public classes
event-class: Public classes
event-class.lisp: The deeds/event-class․lisp file
event-condition: Public conditions
event-delivery: Public classes
event-delivery.lisp: The deeds/event-delivery․lisp file
event-direct-slot-definition: Public classes
event-effective-slot-definition: Public classes
event-loop: Public classes
event-loop-condition: Public conditions
event-loop-handler-dependency-cycle-error: Public conditions
event-loop.lisp: The deeds/event-loop․lisp file
event-slot: Public classes
event.lisp: The deeds/event․lisp file

F
File, class-slots.lisp: The deeds/class-slots․lisp file
File, command.lisp: The deeds/command․lisp file
File, deeds.asd: The deeds/deeds․asd file
File, documentation.lisp: The deeds/documentation․lisp file
File, event-class.lisp: The deeds/event-class․lisp file
File, event-delivery.lisp: The deeds/event-delivery․lisp file
File, event-loop.lisp: The deeds/event-loop․lisp file
File, event.lisp: The deeds/event․lisp file
File, forward-class-definitions.lisp: The deeds/forward-class-definitions․lisp file
File, handler.lisp: The deeds/handler․lisp file
File, origin.lisp: The deeds/origin․lisp file
File, package.lisp: The deeds/package․lisp file
File, standard-events.lisp: The deeds/standard-events․lisp file
File, toolkit.lisp: The deeds/toolkit․lisp file
forward-class-definitions.lisp: The deeds/forward-class-definitions․lisp file

G
globally-blocking-handler: Public classes

H
handler: Public classes
handler-condition: Public conditions
handler-thread-stop-failed-warning: Public conditions
handler.lisp: The deeds/handler․lisp file

I
identified-event: Public classes
immutable-event-slot-has-writer: Public conditions
immutable-event-slot-modified: Public conditions
info-event: Public classes

L
locally-blocking-handler: Public classes

M
message-event: Public classes

O
one-time-handler: Public classes
origin.lisp: The deeds/origin․lisp file

P
Package, deeds: The deeds package
package.lisp: The deeds/package․lisp file
parallel-handler: Public classes
payload-event: Public classes

Q
queued-event-delivery: Public classes
queued-handler: Public classes

S
sequence-event: Public classes
sorted-event-loop: Public classes
standard-events.lisp: The deeds/standard-events․lisp file
stream-begin-event: Public classes
stream-end-event: Public classes
stream-event: Public classes
stream-payload-event: Public classes
System, deeds: The deeds system

T
toolkit.lisp: The deeds/toolkit․lisp file

W
warning-event: Public classes

Jump to:   %  
B   C   D   E   F   G   H   I   L   M   O   P   Q   S   T   W