The deeds Reference Manual

Table of Contents

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

The deeds Reference Manual

This is the deeds Reference Manual, version 1.1.0, generated automatically by Declt version 2.3 "Robert April" on Tue Feb 20 08:33:16 2018 GMT+0.


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

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.


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

2 Systems

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


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

2.1 deeds

Maintainer

Nicolas Hafner <shinmera@tymoon.eu>

Author

Nicolas Hafner <shinmera@tymoon.eu>

Home Page

https://github.com/Shinmera/deeds

License

Artistic

Description

Deeds Extensible Event Delivery System

Version

1.1.0

Dependencies
Source

deeds.asd (file)

Components

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

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 files   [Contents][Index]

3.1.1 deeds.asd

Location

deeds.asd

Systems

deeds (system)


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

3.1.2 deeds/package.lisp

Parent

deeds (system)

Location

package.lisp

Packages

deeds


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

3.1.3 deeds/class-slots.lisp

Dependency

package.lisp (file)

Parent

deeds (system)

Location

class-slots.lisp

Exported Definitions

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

3.1.4 deeds/toolkit.lisp

Dependency

class-slots.lisp (file)

Parent

deeds (system)

Location

toolkit.lisp

Exported Definitions

with-fuzzy-slot-bindings (macro)

Internal Definitions

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

3.1.5 deeds/origin.lisp

Dependency

toolkit.lisp (file)

Parent

deeds (system)

Location

origin.lisp

Exported Definitions

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

3.1.6 deeds/forward-class-definitions.lisp

Dependency

origin.lisp (file)

Parent

deeds (system)

Location

forward-class-definitions.lisp

Exported Definitions

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

3.1.7 deeds/event.lisp

Dependency

forward-class-definitions.lisp (file)

Parent

deeds (system)

Location

event.lisp

Exported Definitions
Internal Definitions

check-event-slots (function)


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

3.1.8 deeds/standard-events.lisp

Dependency

event.lisp (file)

Parent

deeds (system)

Location

standard-events.lisp

Exported Definitions
Internal Definitions

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

3.1.9 deeds/event-delivery.lisp

Dependency

standard-events.lisp (file)

Parent

deeds (system)

Location

event-delivery.lisp

Exported Definitions
Internal Definitions

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

3.1.10 deeds/event-loop.lisp

Dependency

event-delivery.lisp (file)

Parent

deeds (system)

Location

event-loop.lisp

Exported Definitions
Internal Definitions

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

3.1.11 deeds/handler.lisp

Dependency

event-loop.lisp (file)

Parent

deeds (system)

Location

handler.lisp

Exported Definitions
Internal Definitions

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

3.1.12 deeds/command.lisp

Dependency

handler.lisp (file)

Parent

deeds (system)

Location

command.lisp

Exported Definitions

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

3.1.13 deeds/documentation.lisp

Dependency

command.lisp (file)

Parent

deeds (system)

Location

documentation.lisp

Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 deeds

Source

package.lisp (file)

Nickname

org.shirakumo.deeds

Use List

common-lisp

Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [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 (file)

Special Variable: *standard-event-loop*

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

Package

deeds

Source

event-loop.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

Macro: here ()

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

Package

deeds

Source

origin.lisp (file)

Macro: with-awaiting RESPONSE (&key FILTER TIMEOUT LOOP) SETUP-FORM &body BODY
Package

deeds

Source

handler.lisp (file)

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 (file)

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 (file)

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.lisp (file)

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 (file)

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 (file)

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 (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 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 (file)

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 (file)

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 (file)

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 (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 Generic functions

Generic Function: after OBJECT

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

Package

deeds

Methods
Method: after (HANDLER handler)

automatically generated reader method

Source

handler.lisp (file)

Generic Function: before OBJECT

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

Package

deeds

Methods
Method: before (HANDLER handler)

automatically generated reader method

Source

handler.lisp (file)

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 (file)

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 (file)

Methods
Method: cancel (EVENT event)
Generic Function: cancelled OBJECT

Accessor to whether the event has been cancelled.

See CANCEL

Package

deeds

Writer

(setf cancelled) (generic function)

Methods
Method: cancelled (EVENT event)

automatically generated reader method

Source

event.lisp (file)

Generic Function: (setf cancelled) NEW-VALUE OBJECT
Package

deeds

Reader

cancelled (generic function)

Methods
Method: (setf cancelled) NEW-VALUE (EVENT event)

automatically generated writer method

Source

event.lisp (file)

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

Writer

(setf class-all-direct-slots) (generic function)

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

class-slots.lisp (file)

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

class-slots.lisp (file)

Method: class-all-direct-slots (CACHED-SLOTS-CLASS cached-slots-class)

automatically generated reader method

Source

class-slots.lisp (file)

Generic Function: (setf class-all-direct-slots) NEW-VALUE OBJECT
Package

deeds

Reader

class-all-direct-slots (generic function)

Methods
Method: (setf class-all-direct-slots) NEW-VALUE (CACHED-SLOTS-CLASS cached-slots-class)

automatically generated writer method

Source

class-slots.lisp (file)

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 (file)

Methods
Method: deliver-event-directly (EVENT event) (EVENT-LOOP sorted-event-loop)
Method: deliver-event-directly (EVENT event) (EVENT-LOOP event-loop)
Generic Function: delivery-function OBJECT

The function that is used to deliver events.

See HANDLE

Package

deeds

Writer

(setf delivery-function) (generic function)

Methods
Method: delivery-function (EVENT-DELIVERY event-delivery)

automatically generated reader method

Source

event-delivery.lisp (file)

Generic Function: (setf delivery-function) NEW-VALUE OBJECT
Package

deeds

Reader

delivery-function (generic function)

Methods
Method: (setf delivery-function) NEW-VALUE (EVENT-DELIVERY event-delivery)

automatically generated writer method

Source

event-delivery.lisp (file)

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 (file)

Methods
Method: deregister-handler (HANDLERS list) (EVENT-LOOP compiled-event-loop) after
Method: deregister-handler (HANDLERS list) (EVENT-LOOP sorted-event-loop) after
Method: deregister-handler (NAME symbol) (EVENT-LOOP event-loop)
Method: deregister-handler (HANDLERS list) (EVENT-LOOP event-loop)
Method: deregister-handler (HANDLERS list) (EVENT-LOOP event-loop) around
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 (file)

Methods
Method: ensure-handlers-sorted (EVENT-LOOP sorted-event-loop)
Generic Function: event-condition-event CONDITION

The event that the event condition is about.

Package

deeds

Writer

(setf event-condition-event) (generic function)

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

forward-class-definitions.lisp (file)

Generic Function: (setf event-condition-event) NEW-VALUE CONDITION
Package

deeds

Reader

event-condition-event (generic function)

Methods
Method: (setf event-condition-event) NEW-VALUE (CONDITION event-condition)
Source

forward-class-definitions.lisp (file)

Generic Function: event-condition-slot CONDITION

The slot that the event condition is about.

Package

deeds

Writer

(setf event-condition-slot) (generic function)

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

forward-class-definitions.lisp (file)

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

forward-class-definitions.lisp (file)

Generic Function: (setf event-condition-slot) NEW-VALUE CONDITION
Package

deeds

Reader

event-condition-slot (generic function)

Methods
Method: (setf event-condition-slot) NEW-VALUE (CONDITION immutable-event-slot-has-writer)
Source

forward-class-definitions.lisp (file)

Method: (setf event-condition-slot) NEW-VALUE (CONDITION immutable-event-slot-modified)
Source

forward-class-definitions.lisp (file)

Generic Function: event-condition-value CONDITION

The value that the event condition is about.

Package

deeds

Writer

(setf event-condition-value) (generic function)

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

forward-class-definitions.lisp (file)

Generic Function: (setf event-condition-value) NEW-VALUE CONDITION
Package

deeds

Reader

event-condition-value (generic function)

Methods
Method: (setf event-condition-value) NEW-VALUE (CONDITION immutable-event-slot-modified)
Source

forward-class-definitions.lisp (file)

Generic Function: event-condition-writers CONDITION

The writers that the event condition is about.

Package

deeds

Writer

(setf event-condition-writers) (generic function)

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

forward-class-definitions.lisp (file)

Generic Function: (setf event-condition-writers) NEW-VALUE CONDITION
Package

deeds

Reader

event-condition-writers (generic function)

Methods
Method: (setf event-condition-writers) NEW-VALUE (CONDITION immutable-event-slot-has-writer)
Source

forward-class-definitions.lisp (file)

Generic Function: event-loop OBJECT
Package

deeds

Methods
Method: event-loop (EVENT event)

automatically generated reader method

Source

event.lisp (file)

Generic Function: event-loop-condition-event-loop CONDITION

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

Package

deeds

Writer

(setf event-loop-condition-event-loop) (generic function)

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

forward-class-definitions.lisp (file)

Generic Function: (setf event-loop-condition-event-loop) NEW-VALUE CONDITION
Package

deeds

Reader

event-loop-condition-event-loop (generic function)

Methods
Method: (setf event-loop-condition-event-loop) NEW-VALUE (CONDITION event-loop-condition)
Source

forward-class-definitions.lisp (file)

Generic Function: event-loop-condition-handler CONDITION

The handler that the event-loop condition is about.

Package

deeds

Writer

(setf event-loop-condition-handler) (generic function)

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

forward-class-definitions.lisp (file)

Generic Function: (setf event-loop-condition-handler) NEW-VALUE CONDITION
Package

deeds

Reader

event-loop-condition-handler (generic function)

Methods
Method: (setf event-loop-condition-handler) NEW-VALUE (CONDITION event-loop-handler-dependency-cycle-error)
Source

forward-class-definitions.lisp (file)

Generic Function: 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

Writer

(setf event-loop-lock) (generic function)

Methods
Method: event-loop-lock (EVENT-LOOP event-loop)

automatically generated reader method

Source

event-loop.lisp (file)

Generic Function: (setf event-loop-lock) NEW-VALUE OBJECT
Package

deeds

Reader

event-loop-lock (generic function)

Methods
Method: (setf event-loop-lock) NEW-VALUE (EVENT-LOOP event-loop)

automatically generated writer method

Source

event-loop.lisp (file)

Generic Function: event-slot-mutable OBJECT

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

See EVENT-SLOT

Package

deeds

Writer

(setf event-slot-mutable) (generic function)

Methods
Method: event-slot-mutable (EVENT-SLOT event-slot)

automatically generated reader method

Source

event.lisp (file)

Generic Function: (setf event-slot-mutable) NEW-VALUE OBJECT
Package

deeds

Reader

event-slot-mutable (generic function)

Methods
Method: (setf event-slot-mutable) NEW-VALUE (EVENT-SLOT event-slot)

automatically generated writer method

Source

event.lisp (file)

Generic Function: event-type OBJECT

The event-type that the handler accepts.

Package

deeds

Methods
Method: event-type (HANDLER handler)

automatically generated reader method

Source

handler.lisp (file)

Generic Function: filter OBJECT

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

See TEST-FILTER

Package

deeds

Methods
Method: filter (HANDLER handler)

automatically generated reader method

Source

handler.lisp (file)

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 (file)

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

handler.lisp (file)

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

handler.lisp (file)

Method: handle (EVENT event) (GLOBALLY-BLOCKING-HANDLER globally-blocking-handler)
Source

handler.lisp (file)

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

handler.lisp (file)

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

event-loop.lisp (file)

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

event-loop.lisp (file)

Method: handle (EVENT blocking-event) (EVENT-DELVIERY event-delivery) after
Method: handle (EVENT event) (EVENT-DELIVERY event-delivery)
Method: handle (EVENT event) (EVENT-DELIVERY event-delivery) around
Generic Function: handle-cancelled OBJECT

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

Package

deeds

Methods
Method: handle-cancelled (HANDLER handler)

automatically generated reader method

Source

handler.lisp (file)

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 (file)

Writer

(setf handler) (generic function)

Methods
Method: handler (HANDLER handler) (EVENT-LOOP event-loop)
Method: handler (NAME symbol) (EVENT-LOOP event-loop)
Generic Function: (setf handler) HANDLER EVENT-LOOP
Package

deeds

Source

event-loop.lisp (file)

Reader

handler (generic function)

Methods
Method: (setf handler) (HANDLER handler) (EVENT-LOOP event-loop)
Generic Function: handler-condition-handler CONDITION

The handler that the handler condition is about.

Package

deeds

Writer

(setf handler-condition-handler) (generic function)

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

forward-class-definitions.lisp (file)

Generic Function: (setf handler-condition-handler) NEW-VALUE CONDITION
Package

deeds

Reader

handler-condition-handler (generic function)

Methods
Method: (setf handler-condition-handler) NEW-VALUE (CONDITION handler-condition)
Source

forward-class-definitions.lisp (file)

Generic Function: handler-condition-thread CONDITION

The thread that the handler condition is about.

Package

deeds

Writer

(setf handler-condition-thread) (generic function)

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

forward-class-definitions.lisp (file)

Generic Function: (setf handler-condition-thread) NEW-VALUE CONDITION
Package

deeds

Reader

handler-condition-thread (generic function)

Methods
Method: (setf handler-condition-thread) NEW-VALUE (CONDITION handler-thread-stop-failed-warning)
Source

forward-class-definitions.lisp (file)

Generic Function: handler-lock OBJECT

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

See THREADS

Package

deeds

Writer

(setf handler-lock) (generic function)

Methods
Method: handler-lock (GLOBALLY-BLOCKING-HANDLER globally-blocking-handler)

automatically generated reader method

Source

handler.lisp (file)

Method: handler-lock (PARALLEL-HANDLER parallel-handler)

automatically generated reader method

Source

handler.lisp (file)

Generic Function: (setf handler-lock) NEW-VALUE OBJECT
Package

deeds

Reader

handler-lock (generic function)

Methods
Method: (setf handler-lock) NEW-VALUE (GLOBALLY-BLOCKING-HANDLER globally-blocking-handler)

automatically generated writer method

Source

handler.lisp (file)

Method: (setf handler-lock) NEW-VALUE (PARALLEL-HANDLER parallel-handler)

automatically generated writer method

Source

handler.lisp (file)

Generic Function: 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

Writer

(setf handlers) (generic function)

Methods
Method: handlers (EVENT-LOOP event-loop)

automatically generated reader method

Source

event-loop.lisp (file)

Generic Function: (setf handlers) NEW-VALUE OBJECT
Package

deeds

Reader

handlers (generic function)

Methods
Method: (setf handlers) NEW-VALUE (EVENT-LOOP event-loop)

automatically generated writer method

Source

event-loop.lisp (file)

Generic Function: identifier OBJECT

The unique identifier of the group the event belongs to.

Package

deeds

Methods
Method: identifier (IDENTIFIED-EVENT identified-event)

automatically generated reader method

Source

standard-events.lisp (file)

Generic Function: index OBJECT

The position of the event within the sequence.

Package

deeds

Methods
Method: index (SEQUENCE-EVENT sequence-event)

automatically generated reader method

Source

standard-events.lisp (file)

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.

Package

deeds

Source

event-delivery.lisp (file)

Methods
Method: issue (BLOCKING-EVENT blocking-event) (PARALLEL-HANDLER parallel-handler)
Source

handler.lisp (file)

Method: issue (EVENT event) (PARALLEL-HANDLER parallel-handler)
Source

handler.lisp (file)

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

event-loop.lisp (file)

Method: issue (EVENT blocking-event) (EVENT-DELIVERY queued-event-delivery) after
Method: issue (EVENT event) (EVENT-DELIVERY queued-event-delivery)
Method: issue (EVENT event) (EVENT-DELIVERY event-delivery)
Generic Function: issue-time OBJECT

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

See ISSUE.

Package

deeds

Writer

(setf issue-time) (generic function)

Methods
Method: issue-time (EVENT event)

automatically generated reader method

Source

event.lisp (file)

Generic Function: (setf issue-time) NEW-VALUE OBJECT
Package

deeds

Reader

issue-time (generic function)

Methods
Method: (setf issue-time) NEW-VALUE (EVENT event)

automatically generated writer method

Source

event.lisp (file)

Generic Function: loops OBJECT

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

Package

deeds

Writer

(setf loops) (generic function)

Methods
Method: loops (HANDLER handler)

automatically generated reader method

Source

handler.lisp (file)

Generic Function: (setf loops) NEW-VALUE OBJECT
Package

deeds

Reader

loops (generic function)

Methods
Method: (setf loops) NEW-VALUE (HANDLER handler)

automatically generated writer method

Source

handler.lisp (file)

Generic Function: 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
Method: max-index (SEQUENCE-EVENT sequence-event)

automatically generated reader method

Source

standard-events.lisp (file)

Generic Function: message OBJECT

The message of the message-event.

Package

deeds

Methods
Method: message (MESSAGE-EVENT message-event)

automatically generated reader method

Source

standard-events.lisp (file)

Generic Function: name OBJECT

Returns a symbol describing the name of the object.

Package

deeds

Methods
Method: name (HANDLER handler)

automatically generated reader method

Source

handler.lisp (file)

Generic Function: origin OBJECT

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

See *ORIGIN*
See WITH-ORIGIN

Package

deeds

Methods
Method: origin (EVENT event)

automatically generated reader method

Source

event.lisp (file)

Generic Function: payload OBJECT

The payload of to be delivered.

Package

deeds

Methods
Method: payload (PAYLOAD-EVENT payload-event)

automatically generated reader method

Source

standard-events.lisp (file)

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 (file)

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 (file)

Methods
Method: register-handler (HANDLERS list) (EVENT-LOOP compiled-event-loop) after
Method: register-handler (HANDLERS list) (EVENT-LOOP sorted-event-loop) after
Method: register-handler (HANDLERS list) (EVENT-LOOP event-loop)
Method: register-handler (HANDLERS list) (EVENT-LOOP event-loop) around
Method: register-handler (HANDLER handler) (EVENT-LOOP event-loop)
Generic Function: response-event OBJECT

Accessor to the response event the handler captures.

Package

deeds

Writer

(setf response-event) (generic function)

Methods
Method: response-event (CONDITION-NOTIFY-HANDLER condition-notify-handler)

automatically generated reader method

Source

handler.lisp (file)

Generic Function: (setf response-event) NEW-VALUE OBJECT
Package

deeds

Reader

response-event (generic function)

Methods
Method: (setf response-event) NEW-VALUE (CONDITION-NOTIFY-HANDLER condition-notify-handler)

automatically generated writer method

Source

handler.lisp (file)

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 (file)

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

event-delivery.lisp (file)

Method: running (STUFF list)
Source

event-delivery.lisp (file)

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 (file)

Methods
Method: sort-handlers (HANDLERS list) (EVENT-LOOP sorted-event-loop)
Method: sort-handlers (HANDLERS hash-table) (EVENT-LOOP sorted-event-loop)
Generic Function: 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

Writer

(setf sorted-handlers) (generic function)

Methods
Method: sorted-handlers (SORTED-EVENT-LOOP sorted-event-loop)

automatically generated reader method

Source

event-loop.lisp (file)

Generic Function: (setf sorted-handlers) NEW-VALUE OBJECT
Package

deeds

Reader

sorted-handlers (generic function)

Methods
Method: (setf sorted-handlers) NEW-VALUE (SORTED-EVENT-LOOP sorted-event-loop)

automatically generated writer method

Source

event-loop.lisp (file)

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 (file)

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 the delivery is already stopped this does nothing.

Package

deeds

Source

event-delivery.lisp (file)

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

handler.lisp (file)

Method: stop (EVENT-DELIVERY queued-event-delivery)
Method: stop (EVENT-DELIVERY event-delivery)
Method: stop (STUFF list)
Generic Function: threads OBJECT

The threads of the parallel-handler.

Package

deeds

Writer

(setf threads) (generic function)

Methods
Method: threads (PARALLEL-HANDLER parallel-handler)

automatically generated reader method

Source

handler.lisp (file)

Generic Function: (setf threads) NEW-VALUE OBJECT
Package

deeds

Reader

threads (generic function)

Methods
Method: (setf threads) NEW-VALUE (PARALLEL-HANDLER parallel-handler)

automatically generated writer method

Source

handler.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.5 Conditions

Condition: event-condition ()

Condition base class for conditions related to events.

See EVENT-CONDITION-EVENT

Package

deeds

Source

forward-class-definitions.lisp (file)

Direct superclasses

condition (condition)

Direct subclasses
Direct methods
Direct slots
Slot: event
Initargs

:event

Readers

event-condition-event (generic function)

Writers

(setf event-condition-event) (generic function)

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 (file)

Direct superclasses

condition (condition)

Direct subclasses

event-loop-handler-dependency-cycle-error (condition)

Direct methods
Direct slots
Slot: event-loop
Initargs

:event-loop

Readers

event-loop-condition-event-loop (generic function)

Writers

(setf event-loop-condition-event-loop) (generic function)

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 (file)

Direct superclasses
Direct methods
Direct slots
Slot: handler
Initargs

:handler

Readers

event-loop-condition-handler (generic function)

Writers

(setf event-loop-condition-handler) (generic function)

Condition: handler-condition ()

Condition base class for conditions related to handlers.

See HANDLER-CONDITION-HANDLER

Package

deeds

Source

forward-class-definitions.lisp (file)

Direct superclasses

condition (condition)

Direct subclasses

handler-thread-stop-failed-warning (condition)

Direct methods
Direct slots
Slot: handler
Initargs

:handler

Readers

handler-condition-handler (generic function)

Writers

(setf handler-condition-handler) (generic function)

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 (file)

Direct superclasses
Direct methods
Direct slots
Slot: thread
Initargs

:thread

Readers

handler-condition-thread (generic function)

Writers

(setf handler-condition-thread) (generic function)

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 (file)

Direct superclasses
Direct methods
Direct slots
Slot: slot
Initargs

:slot

Readers

event-condition-slot (generic function)

Writers

(setf event-condition-slot) (generic function)

Slot: writers
Initargs

:writers

Readers

event-condition-writers (generic function)

Writers

(setf event-condition-writers) (generic function)

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 (file)

Direct superclasses
Direct methods
Direct slots
Slot: slot
Initargs

:slot

Readers

event-condition-slot (generic function)

Writers

(setf event-condition-slot) (generic function)

Slot: value
Initargs

:value

Readers

event-condition-value (generic function)

Writers

(setf event-condition-value) (generic function)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.6 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 (file)

Direct superclasses

event (class)

Direct methods
Direct slots
Slot: done
Readers

done (generic function)

Writers

(setf done) (generic function)

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 (file)

Direct superclasses

standard-class (class)

Direct subclasses

event-class (class)

Direct methods
  • reinitialize-instance (method)
  • initialize-instance (method)
  • validate-superclass (method)
  • validate-superclass (method)
  • validate-superclass (method)
  • validate-superclass (method)
  • class-all-direct-slots (method)
  • class-all-direct-slots (method)
Direct slots
Slot: class-all-direct-slots
Readers

class-all-direct-slots (generic function)

Writers

(setf class-all-direct-slots) (generic function)

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 (file)

Direct superclasses
Class: command-event ()

Event used for commands

See DEFINE-COMMAND

Package

deeds

Source

command.lisp (file)

Direct superclasses

event (class)

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 (file)

Direct superclasses

sorted-event-loop (class)

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 (file)

Direct superclasses

one-time-handler (class)

Direct methods
Direct slots
Slot: condition-variable
Initform

(bordeaux-threads:make-condition-variable)

Readers

condition-variable (generic function)

Writers

(setf condition-variable) (generic function)

Slot: issue-synchronizer-lock
Initform

(bordeaux-threads:make-lock)

Readers

issue-synchronizer-lock (generic function)

Writers

(setf issue-synchronizer-lock) (generic function)

Slot: response-event
Readers

response-event (generic function)

Writers

(setf response-event) (generic function)

Class: error-event ()

Delivers an error message.

See MESSAGE-EVENT

Package

deeds

Source

standard-events.lisp (file)

Direct superclasses

message-event (class)

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 (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: origin
Initargs

:origin

Readers

origin (generic function)

Slot: event-loop
Readers

event-loop (generic function)

Slot: issue-time
Readers

issue-time (generic function)

Writers

(setf issue-time) (generic function)

Slot: cancelled
Readers

cancelled (generic function)

Writers

(setf cancelled) (generic function)

Direct Default Initargs
InitargValue
:origindeeds:*origin*
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.lisp (file)

Direct superclasses

cached-slots-class (class)

Direct methods
  • slot-value-using-class (method)
  • compute-effective-slot-definition (method)
  • effective-slot-definition-class (method)
  • direct-slot-definition-class (method)
  • reinitialize-instance (method)
  • initialize-instance (method)
  • validate-superclass (method)
  • validate-superclass (method)
  • validate-superclass (method)
  • validate-superclass (method)
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 (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: delivery-function
Initargs

:delivery-function

Readers

delivery-function (generic function)

Writers

(setf delivery-function) (generic function)

Direct Default Initargs
InitargValue
:delivery-function(function print)
Class: event-direct-slot-definition ()

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

Package

deeds

Source

event.lisp (file)

Direct superclasses
  • standard-direct-slot-definition (class)
  • event-slot (class)
Class: event-effective-slot-definition ()

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

Package

deeds

Source

event.lisp (file)

Direct superclasses
  • standard-effective-slot-definition (class)
  • event-slot (class)
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 (file)

Direct superclasses

queued-event-delivery (class)

Direct subclasses

sorted-event-loop (class)

Direct methods
Direct slots
Slot: handlers
Initform

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

Readers

handlers (generic function)

Writers

(setf handlers) (generic function)

Slot: event-loop-lock
Readers

event-loop-lock (generic function)

Writers

(setf event-loop-lock) (generic function)

Direct Default Initargs
InitargValue
:delivery-functionnil
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.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: mutable
Initargs

:mutable

Readers

event-slot-mutable (generic function)

Writers

(setf event-slot-mutable) (generic function)

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 (file)

Direct superclasses

handler (class)

Direct methods
Direct slots
Slot: handler-lock
Initform

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

Readers

handler-lock (generic function)

Writers

(setf handler-lock) (generic function)

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 (file)

Direct superclasses

event-delivery (class)

Direct subclasses
Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name (generic function)

Slot: event-type
Initargs

:event-type

Readers

event-type (generic function)

Slot: filter
Initargs

:filter

Readers

filter (generic function)

Slot: before
Initargs

:before

Readers

before (generic function)

Slot: after
Initargs

:after

Readers

after (generic function)

Slot: handle-cancelled
Initargs

:handle-cancelled

Readers

handle-cancelled (generic function)

Slot: loops
Readers

loops (generic function)

Writers

(setf loops) (generic function)

Direct Default Initargs
InitargValue
:namenil
:event-type(quote deeds:event)
:filternil
:beforenil
:afternil
:handle-cancellednil
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 (file)

Direct superclasses

event (class)

Direct subclasses

stream-event (class)

Direct methods
  • initialize-instance (method)
  • identifier (method)
Direct slots
Slot: identifier
Initargs

:identifier

Readers

identifier (generic function)

Class: info-event ()

Delivers an informational message.

See MESSAGE-EVENT

Package

deeds

Source

standard-events.lisp (file)

Direct superclasses

message-event (class)

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 (file)

Direct superclasses

handler (class)

Class: message-event ()

A simple event merely used to deliver message strings.

See EVENT
See MESSAGE

Package

deeds

Source

standard-events.lisp (file)

Direct superclasses

event (class)

Direct subclasses
Direct methods

message (method)

Direct slots
Slot: message
Initargs

:message

Readers

message (generic function)

Direct Default Initargs
InitargValue
:message(error "message required.")
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 (file)

Direct superclasses

handler (class)

Direct subclasses

condition-notify-handler (class)

Direct methods

handle (method)

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 (file)

Direct superclasses

handler (class)

Direct methods
Direct slots
Slot: threads
Readers

threads (generic function)

Writers

(setf threads) (generic function)

Slot: handler-lock
Initform

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

Readers

handler-lock (generic function)

Writers

(setf handler-lock) (generic function)

Class: payload-event ()

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

See EVENT
See PAYLOAD

Package

deeds

Source

standard-events.lisp (file)

Direct superclasses

event (class)

Direct subclasses
Direct methods

payload (method)

Direct slots
Slot: payload
Initargs

:payload

Readers

payload (generic function)

Direct Default Initargs
InitargValue
:payload(error "payload required.")
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 (file)

Direct superclasses

event-delivery (class)

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

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

Readers

front-queue (generic function)

Writers

(setf front-queue) (generic function)

Slot: back-queue
Initform

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

Readers

back-queue (generic function)

Writers

(setf back-queue) (generic function)

Slot: queue-condition
Initform

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

Readers

queue-condition (generic function)

Slot: queue-lock
Initform

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

Readers

queue-lock (generic function)

Slot: queue-thread
Readers

queue-thread (generic function)

Writers

(setf queue-thread) (generic function)

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 (file)

Direct superclasses
Direct methods

print-object (method)

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 (file)

Direct superclasses

event (class)

Direct subclasses

chunked-payload-event (class)

Direct methods
Direct slots
Slot: index
Initargs

:index

Readers

index (generic function)

Slot: max-index
Initargs

:max-index

Readers

max-index (generic function)

Direct Default Initargs
InitargValue
:index(error "index required.")
:max-indexnil
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 (file)

Direct superclasses

event-loop (class)

Direct subclasses

compiled-event-loop (class)

Direct methods
Direct slots
Slot: sorted-handlers
Readers

sorted-handlers (generic function)

Writers

(setf sorted-handlers) (generic function)

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 (file)

Direct superclasses

stream-event (class)

Class: stream-end-event ()

Stream event to signal the end of a stream.

See STREAM-EVENT

Package

deeds

Source

standard-events.lisp (file)

Direct superclasses

stream-event (class)

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 (file)

Direct superclasses

identified-event (class)

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 (file)

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 (file)

Direct superclasses

message-event (class)


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

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Macros

Macro: setdocs &body PAIRS

Easily set the documentation.

Package

deeds

Source

documentation.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 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 (file)

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.lisp (file)

Function: checkdocs &optional PACKAGE

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

Package

deeds

Source

documentation.lisp (file)

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 (file)

Function: compile-test TEST TYPE
Package

deeds

Source

event-loop.lisp (file)

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 (file)

Function: ensure-list A &rest ELEMENTS
Package

deeds

Source

toolkit.lisp (file)

Function: extract-tests HANDLERS
Package

deeds

Source

event-loop.lisp (file)

Function: filter-tests FILTER
Package

deeds

Source

event-loop.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

Function: make-thread FUNC &optional NAME
Package

deeds

Source

toolkit.lisp (file)

Function: removef LIST &rest REMOVE-PROPERTIES

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

Package

deeds

Source

toolkit.lisp (file)

Function: replace-tests FILTER TYPE TESTMAP
Package

deeds

Source

event-loop.lisp (file)

Function: test-gensym TEST
Package

deeds

Source

event-loop.lisp (file)

Function: unlist A
Package

deeds

Source

toolkit.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Generic functions

Generic Function: back-queue OBJECT
Generic Function: (setf back-queue) NEW-VALUE OBJECT
Package

deeds

Methods
Method: back-queue (QUEUED-EVENT-DELIVERY queued-event-delivery)

automatically generated reader method

Source

event-delivery.lisp (file)

Method: (setf back-queue) NEW-VALUE (QUEUED-EVENT-DELIVERY queued-event-delivery)

automatically generated writer method

Source

event-delivery.lisp (file)

Generic Function: condition-variable OBJECT

A condition variable accessor.

Package

deeds

Writer

(setf condition-variable) (generic function)

Methods
Method: condition-variable (CONDITION-NOTIFY-HANDLER condition-notify-handler)

automatically generated reader method

Source

handler.lisp (file)

Generic Function: (setf condition-variable) NEW-VALUE OBJECT
Package

deeds

Reader

condition-variable (generic function)

Methods
Method: (setf condition-variable) NEW-VALUE (CONDITION-NOTIFY-HANDLER condition-notify-handler)

automatically generated writer method

Source

handler.lisp (file)

Generic Function: done OBJECT
Generic Function: (setf done) NEW-VALUE OBJECT
Package

deeds

Methods
Method: done (BLOCKING-EVENT blocking-event)

automatically generated reader method

Source

standard-events.lisp (file)

Method: (setf done) NEW-VALUE (BLOCKING-EVENT blocking-event)

automatically generated writer method

Source

standard-events.lisp (file)

Generic Function: front-queue OBJECT
Generic Function: (setf front-queue) NEW-VALUE OBJECT
Package

deeds

Methods
Method: front-queue (QUEUED-EVENT-DELIVERY queued-event-delivery)

automatically generated reader method

Source

event-delivery.lisp (file)

Method: (setf front-queue) NEW-VALUE (QUEUED-EVENT-DELIVERY queued-event-delivery)

automatically generated writer method

Source

event-delivery.lisp (file)

Generic Function: issue-synchronizer-lock OBJECT

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

Package

deeds

Writer

(setf issue-synchronizer-lock) (generic function)

Methods
Method: issue-synchronizer-lock (CONDITION-NOTIFY-HANDLER condition-notify-handler)

automatically generated reader method

Source

handler.lisp (file)

Generic Function: (setf issue-synchronizer-lock) NEW-VALUE OBJECT
Package

deeds

Reader

issue-synchronizer-lock (generic function)

Methods
Method: (setf issue-synchronizer-lock) NEW-VALUE (CONDITION-NOTIFY-HANDLER condition-notify-handler)

automatically generated writer method

Source

handler.lisp (file)

Generic Function: process-delivery-queue EVENT-DELIVERY
Package

deeds

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

event-delivery.lisp (file)

Generic Function: queue-condition OBJECT
Package

deeds

Methods
Method: queue-condition (QUEUED-EVENT-DELIVERY queued-event-delivery)

automatically generated reader method

Source

event-delivery.lisp (file)

Generic Function: queue-lock OBJECT
Package

deeds

Methods
Method: queue-lock (QUEUED-EVENT-DELIVERY queued-event-delivery)

automatically generated reader method

Source

event-delivery.lisp (file)

Generic Function: queue-thread OBJECT
Generic Function: (setf queue-thread) NEW-VALUE OBJECT
Package

deeds

Methods
Method: queue-thread (QUEUED-EVENT-DELIVERY queued-event-delivery)

automatically generated reader method

Source

event-delivery.lisp (file)

Method: (setf queue-thread) NEW-VALUE (QUEUED-EVENT-DELIVERY queued-event-delivery)

automatically generated writer method

Source

event-delivery.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   D   F   L  
Index Entry  Section

D
deeds.asd: The deeds<dot>asd file
deeds/class-slots.lisp: The deeds/class-slots<dot>lisp file
deeds/command.lisp: The deeds/command<dot>lisp file
deeds/documentation.lisp: The deeds/documentation<dot>lisp file
deeds/event-delivery.lisp: The deeds/event-delivery<dot>lisp file
deeds/event-loop.lisp: The deeds/event-loop<dot>lisp file
deeds/event.lisp: The deeds/event<dot>lisp file
deeds/forward-class-definitions.lisp: The deeds/forward-class-definitions<dot>lisp file
deeds/handler.lisp: The deeds/handler<dot>lisp file
deeds/origin.lisp: The deeds/origin<dot>lisp file
deeds/package.lisp: The deeds/package<dot>lisp file
deeds/standard-events.lisp: The deeds/standard-events<dot>lisp file
deeds/toolkit.lisp: The deeds/toolkit<dot>lisp file

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

L
Lisp File, deeds.asd: The deeds<dot>asd file
Lisp File, deeds/class-slots.lisp: The deeds/class-slots<dot>lisp file
Lisp File, deeds/command.lisp: The deeds/command<dot>lisp file
Lisp File, deeds/documentation.lisp: The deeds/documentation<dot>lisp file
Lisp File, deeds/event-delivery.lisp: The deeds/event-delivery<dot>lisp file
Lisp File, deeds/event-loop.lisp: The deeds/event-loop<dot>lisp file
Lisp File, deeds/event.lisp: The deeds/event<dot>lisp file
Lisp File, deeds/forward-class-definitions.lisp: The deeds/forward-class-definitions<dot>lisp file
Lisp File, deeds/handler.lisp: The deeds/handler<dot>lisp file
Lisp File, deeds/origin.lisp: The deeds/origin<dot>lisp file
Lisp File, deeds/package.lisp: The deeds/package<dot>lisp file
Lisp File, deeds/standard-events.lisp: The deeds/standard-events<dot>lisp file
Lisp File, deeds/toolkit.lisp: The deeds/toolkit<dot>lisp file

Jump to:   D   F   L  

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   W  
Index Entry  Section

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

A
after: Exported generic functions
after: Exported generic functions

B
back-queue: Internal generic functions
back-queue: Internal generic functions
before: Exported generic functions
before: Exported generic functions
broadcast: Exported functions
build-event-loop: Exported generic functions
build-event-loop: Exported generic functions
build-fuzzy-slot-accessor: Internal functions

C
cancel: Exported generic functions
cancel: Exported generic functions
cancelled: Exported generic functions
cancelled: Exported generic functions
check-event-slots: Internal functions
checkdocs: Internal functions
class-all-direct-slots: Exported generic functions
class-all-direct-slots: Exported generic functions
class-all-direct-slots: Exported generic functions
class-all-direct-slots: Exported generic functions
compile-lambda: Internal functions
compile-test: Internal functions
compute-all-direct-slots: Exported functions
condition-variable: Internal generic functions
condition-variable: Internal generic functions
copy-hash-table: Internal functions

D
define-cached-slots-class: Exported macros
define-command: Exported macros
define-event: Exported macros
define-handler: Exported macros
deliver-event-directly: Exported generic functions
deliver-event-directly: Exported generic functions
deliver-event-directly: Exported generic functions
delivery-function: Exported generic functions
delivery-function: Exported generic functions
deregister-handler: Exported generic functions
deregister-handler: Exported generic functions
deregister-handler: Exported generic functions
deregister-handler: Exported generic functions
deregister-handler: Exported generic functions
deregister-handler: Exported generic functions
deregister-handler: Exported generic functions
do-issue: Exported macros
done: Internal generic functions
done: Internal generic functions

E
ensure-handlers-sorted: Exported generic functions
ensure-handlers-sorted: Exported generic functions
ensure-list: Internal functions
event-condition-event: Exported generic functions
event-condition-event: Exported generic functions
event-condition-slot: Exported generic functions
event-condition-slot: Exported generic functions
event-condition-slot: Exported generic functions
event-condition-value: Exported generic functions
event-condition-value: Exported generic functions
event-condition-writers: Exported generic functions
event-condition-writers: Exported generic functions
event-loop: Exported generic functions
event-loop: Exported generic functions
event-loop-condition-event-loop: Exported generic functions
event-loop-condition-event-loop: Exported generic functions
event-loop-condition-handler: Exported generic functions
event-loop-condition-handler: Exported generic functions
event-loop-lock: Exported generic functions
event-loop-lock: Exported generic functions
event-slot-mutable: Exported generic functions
event-slot-mutable: Exported generic functions
event-type: Exported generic functions
event-type: Exported generic functions
extract-tests: Internal functions

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

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

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

I
identifier: Exported generic functions
identifier: Exported generic functions
index: Exported generic functions
index: Exported generic functions
issue: Exported generic functions
issue: Exported generic functions
issue: Exported generic functions
issue: Exported generic functions
issue: Exported generic functions
issue: Exported generic functions
issue: Exported generic functions
issue-synchronizer-lock: Internal generic functions
issue-synchronizer-lock: Internal generic functions
issue-time: Exported generic functions
issue-time: Exported generic functions

L
loops: Exported generic functions
loops: Exported generic functions

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

N
name: Exported generic functions
name: Exported generic functions

O
origin: Exported generic functions
origin: Exported generic functions

P
payload: Exported generic functions
payload: Exported generic functions
process-delivery-queue: Internal generic functions
process-delivery-queue: Internal generic functions

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

R
recompile-event-loop: Exported generic functions
recompile-event-loop: Exported generic functions
register-handler: Exported generic functions
register-handler: Exported generic functions
register-handler: Exported generic functions
register-handler: Exported generic functions
register-handler: Exported generic functions
register-handler: Exported generic functions
removef: Internal functions
replace-tests: Internal functions
response-event: Exported generic functions
response-event: Exported generic functions
running: Exported generic functions
running: Exported generic functions
running: Exported generic functions
running: Exported generic functions

S
setdocs: Internal macros
sort-handlers: Exported generic functions
sort-handlers: Exported generic functions
sort-handlers: Exported generic functions
sorted-handlers: Exported generic functions
sorted-handlers: Exported generic functions
start: Exported generic functions
start: Exported generic functions
start: Exported generic functions
start: Exported generic functions
stop: Exported generic functions
stop: Exported generic functions
stop: Exported generic functions
stop: Exported generic functions
stop: Exported generic functions

T
test-filter: Exported functions
test-gensym: Internal functions
threads: Exported generic functions
threads: Exported generic functions

U
unlist: Internal functions

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

Jump to:   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   Q   R   S   T   U   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*: Exported special variables
*standard-event-loop*: Exported special variables

A
after: Exported classes

B
back-queue: Exported classes
before: Exported classes

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

D
delivery-function: Exported classes
done: Exported classes

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

F
filter: Exported classes
front-queue: Exported classes

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

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

L
loops: Exported classes

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

N
name: Exported classes

O
origin: Exported classes

P
payload: Exported classes

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

R
response-event: Exported classes

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

T
thread: Exported conditions
threads: Exported classes

V
value: Exported conditions

W
writers: Exported 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   G   H   I   L   M   O   P   Q   S   W  
Index Entry  Section

B
blocking-event: Exported classes

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

D
deeds: The deeds system
deeds: The deeds package

E
error-event: Exported classes
event: Exported classes
event-class: Exported classes
event-condition: Exported conditions
event-delivery: Exported classes
event-direct-slot-definition: Exported classes
event-effective-slot-definition: Exported classes
event-loop: Exported classes
event-loop-condition: Exported conditions
event-loop-handler-dependency-cycle-error: Exported conditions
event-slot: Exported classes

G
globally-blocking-handler: Exported classes

H
handler: Exported classes
handler-condition: Exported conditions
handler-thread-stop-failed-warning: Exported conditions

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

L
locally-blocking-handler: Exported classes

M
message-event: Exported classes

O
one-time-handler: Exported classes

P
Package, deeds: The deeds package
parallel-handler: Exported classes
payload-event: Exported classes

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

S
sequence-event: Exported classes
sorted-event-loop: Exported classes
stream-begin-event: Exported classes
stream-end-event: Exported classes
stream-event: Exported classes
stream-payload-event: Exported classes
System, deeds: The deeds system

W
warning-event: Exported classes

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