The maiden Reference Manual

Table of Contents

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

The maiden Reference Manual

This is the maiden Reference Manual, version 3.1.0, generated automatically by Declt version 2.3 "Robert April" on Wed Mar 14 04:16:42 2018 GMT+0.


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

1 Introduction

About Maiden

Maiden is a collection of systems to help you build applications and libraries that interact with chat servers. It can help you build a chat bot, or a general chat client. It also offers a variety of parts that should make it much easier to write a client for a new chat protocol.

How To Use Maiden as a Bot

If you only care about using Maiden to set up a bot of some kind, the steps to do so are rather straightforward. First we'll want to load in Maiden and all of the modules and components that you'd like to use in your bot.

(ql:quickload '(maiden maiden-irc maiden-commands maiden-silly))

And then we'll create a core with instances of the consumers added to it as we'd like them to be.

(defvar *core* (maiden:make-core
                 '(:maiden-irc :nickname "MaidenTest" :host "irc.freenode.net" :channels ("##testing"))
                 :maiden-commands
                 :maiden-silly))

The make-core command takes either package names (as strings or symbols) of consumers to add, or the direct class name of a consumer. In the former case it'll try to find the appropriate consumer class name on its own.

And that's it. make-core will create a core, instantiate all the consumers, add them to it, and start everything up. A loot of the modules provided for Maiden will make use of some kind of configuration or persistent storage. For the management thereof, see the storage subsystem.

How To Use Maiden as a Framework to Develop With

In order to use Maiden as a framework, you'll first want to define your own system and package as usual for a project. For now we'll just use the maiden-user package to play around in. Next we'll want to define a consumer. This can be done with define-consumer.

(in-package #:maiden-user)
(define-consumer ping-notifier (agent)
  ())

Usually you'll want to define an agent. Agents can only exist once on a core. We'll go through an example for a client later. Now, from here on out we can define our own methods and functions that specialise or act on the consumer class as you'd be used to from general CLOS programming. Next, we'll define our own event that we'll use to send "ping requests" to the system.

(define-event ping (passive-event)
  ())

The event is defined as a passive-event as it is not directly requesting an action to be taken, but rather informs the system of a ping that's happening. Now, in order to actually make the consumer interact with the event system however, we'll also want to define handlers. This can be done with define-handler.

(define-handler (ping-notifier ping-receiver ping) (c ev)
  (v:info :ping "Received a ping: ~a" ev))

This defines a handler called ping-receiver on our ping-notifier consumer. It also specifies that it will listen for events of type ping. The arglist afterwards says that the consumer instance is bound to c and the event instance to ev. The body then simply logs an informational message using Verbose.

Let's test this out real quick.

(defvar *core* (make-core 'ping-notifier))

(do-issue *core* ping)

That should print the status message to the REPL as expected. And that's most of everything there is to using this system. Note that in order to do actually useful things, you'll probably want to make use of some of the preexisting subsystems that the Maiden project delivers aside from the core. Those will help you with users, channels, accounts, commands, networking, storage, and so forth. Also keep in mind that you can make use of the features that Deeds offers on its own as well, such as filtering expressions for handlers.

Now let's take a look at a primitive kind of client. The client will simply be able to write to a file through events.

(define-consumer file-client (client)
  ((file :initarg :file :accessor file))
  (:default-initargs :file (error "FILE required.")))
  
(define-event write-event (client-event active-event)
  ((sequence :initarg :sequence))
  (:default-initargs :sequence (error "SEQUENCE required.")))

We've made the write-event a client-event since it needs to be specific to a client we want to write to, and we've made it an active-event since it requests something to happen. Now let's define our handler that will take care of actually writing the sequence to file.

(define-handler (file-client writer write-event) (c ev sequence)
  :match-consumer 'client
  (with-open-file (stream (file c) :direction :output :if-exists :append :if-does-not-exist :create)
    (write-sequence sequence stream)))

The :match-consumer option modifies the handler's filter in such a way that the filter will only pass events whose client slot contains the same file-client instance as the current handler instance belongs to. This is important, as each instance of file-client will receive its own instances of its handlers on a core. Without this option, the write-event would be handled by every instance of the file-client regardless of which instance the event was intended for. Also note that we added a sequence argument to the handler's arglist. This argument will be filled with the appropriate slot from the event. If no such slot could be found, an error is signalled.

Time to test it out. We'll just reuse the core from above.

(add-to-core *core* '(file-client :file "~/foo" :name :foo)
                    '(file-client :file "~/bar" :name :bar))

(do-issue *core* write-event :sequence "foo" :client (consumer :foo *core*))
(do-issue *core* write-event :sequence "bar" :client (consumer :bar *core*))

(alexandria:read-file-into-string "~/foo") ; => "foo"
(alexandria:read-file-into-string "~/bar") ; => "bar"

As you can see, the events were directed to the appropriate handler instances according to the client we wanted, and the files thus contain what we expect them to.

Finally, it is worth mentioning that it is also possible to dynamically add and remove handlers at runtime, and even do so for handlers that are not associated with a particular consumer. This is often useful when you need to wait for a response event from somewhere. To handle the logic of doing this asynchronously and retain the impression of an imperative flow, Maiden offers --just as Deeds does-- a with-awaiting macro. It can be used as follows:

(with-awaiting (core event-type) (ev some-field)
    (do-issue core initiating-event)
  :timeout 20
  some-field)

with-awaiting is very similar to define-handler, with the exception that it doesn't take a name, and instead of a consumer name at the beginning it needs a core or consumer instance. It also takes one extra option that is otherwise unused, the :timeout. Another required extra is the "setup form" after the arglist. In order to properly manage everything and ensure no race conditions may occur in the system, you must initiate the process that will prompt the eventual response event in this setup form. If you initiate it before then, the response event might be sent out before the temporary handler is set up in the system and it'll appear as if it never arrived at all.

And that's pretty much all of the basics. As mentioned above, take a look at the subsystems this project includes, as they will help you with all sorts of common tasks and problems revolving around chat systems and so on.

Core Documentation

Before understanding Maiden, it is worth it to understand Deeds, if only at a surface level. Maiden builds on it rather heavily.

Core

A core is the central part of a Maiden configuration. It is responsible for managing and orchestrating the other components of the system. You can have multiple cores running simultaneously within the same lisp image, and can even share components between them.

More specifically, a Core is made up of an event-loop and a set of consumers. The event-loop is responsible for delivering events to handlers. Consumers are responsible for attaching handlers to the event-loop. The operations you will most likely want to perform on a core are thus: issuing events to it by issue, adding consumers to it by add-consumer, or removing a consumer from it by remove-consumer.

In order to make it easier on your to create a useful core with consumers added to it, you can make use of the make-core and add-to-core functions.

Event

An event is an object that represents a change in the system. Events can be used to either represent a change that has occurred, or to represents a request for a change to happen. These are called passive-events and active-events respectively.

Generally you will use events in the following ways:

  1. Consuming them by writing a handler that takes events of a particular type and does something in response to them.
  2. Define new event classes that describe certain behaviour.
  3. Emitting them by writing components that inform the system about changes.

Consumer

A consumer is a class that represents a component in the system. Each consumer can have a multitude of handlers tied to it, which will react to events in the system. Consumers come in two basic supertypes, agents and clients. Agents are consumers that should only exist on a core once, as they implement functionality that would not make sense to be multiplexed in some way. Clients on the other hand represent some kind of bridge to an outside system, and naturally should be allowed to have multiple instances on the same core.

Thus developing a set of commands or an interface of some kind would probably lead to an agent, whereas interfacing with a service like XMPP would lead to a client.

Defining a consumer should happen with define-consumer, which is similar to the standard defclass, but ensures that the superclasses and metaclasses are properly set up.

Handler

handlers are objects that hold a function that performs certain actions when a particular event is issued onto the core. Each handler is tied to a particular consumer and is removed or added to the core's event-loop when the consumer is removed or added to the core.

Handler definition happens through one of define-handler, define-function-handler, define-instruction, or define-query. Which each successively build on the last to provide a broader shorthand for common requirements. Note that the way in which a handler actually receives its events can differ. Have a look at the Deeds' documentation to see what handler classes are available.

Subsystems

Included in the Maiden project are a couple of subsystems that extend the core functionality.

Existing Clients

The Maiden project also includes a few standard clients that can be used right away.

Existing Agents

Finally, the project has a bunch of agent modules that provide functionality that is useful for creating chat bots and such. They, too, can be used straight away.


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 maiden

Maintainer

Nicolas Hafner <shinmera@tymoon.eu>

Author

Nicolas Hafner <shinmera@tymoon.eu>

Home Page

https://github.com/Shinmera/maiden

License

Artistic

Description

A modern and extensible chat bot framework.

Version

3.1.0

Dependencies
Source

maiden.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 maiden.asd

Location

maiden.asd

Systems

maiden (system)


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

3.1.2 maiden/package.lisp

Parent

maiden (system)

Location

package.lisp

Packages

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

3.1.3 maiden/toolkit.lisp

Dependency

package.lisp (file)

Parent

maiden (system)

Location

toolkit.lisp

Exported Definitions
Internal Definitions

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

3.1.4 maiden/conditions.lisp

Dependency

toolkit.lisp (file)

Parent

maiden (system)

Location

conditions.lisp

Exported Definitions

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

3.1.5 maiden/event.lisp

Dependency

conditions.lisp (file)

Parent

maiden (system)

Location

event.lisp

Exported Definitions
Internal Definitions

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

3.1.6 maiden/standard-events.lisp

Dependency

event.lisp (file)

Parent

maiden (system)

Location

standard-events.lisp

Exported Definitions

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

3.1.7 maiden/entity.lisp

Dependency

standard-events.lisp (file)

Parent

maiden (system)

Location

entity.lisp

Exported Definitions
Internal Definitions

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

3.1.8 maiden/consumer.lisp

Dependency

entity.lisp (file)

Parent

maiden (system)

Location

consumer.lisp

Exported Definitions
Internal Definitions

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

3.1.9 maiden/core.lisp

Dependency

consumer.lisp (file)

Parent

maiden (system)

Location

core.lisp

Exported Definitions
Internal Definitions

find-entity (method)


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

3.1.10 maiden/agent.lisp

Dependency

core.lisp (file)

Parent

maiden (system)

Location

agent.lisp

Exported Definitions

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

3.1.11 maiden/client.lisp

Dependency

agent.lisp (file)

Parent

maiden (system)

Location

client.lisp

Exported Definitions

client (class)


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

3.1.12 maiden/documentation.lisp

Dependency

client.lisp (file)

Parent

maiden (system)

Location

documentation.lisp


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

4 Packages

Packages are listed by definition order.


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

4.1 maiden-user

Source

package.lisp (file)

Nickname

org.shirakumo.maiden.user

Use List

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

4.2 maiden

Source

package.lisp (file)

Nickname

org.shirakumo.maiden

Use List
Used By List

maiden-user

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: *debugger*

This variable sets whether an internal error should call out to the debugger or not.

On deployed systems, this should probably be NIL. The
default value is whether the SWANK package is present
or not.

Package

maiden

Source

toolkit.lisp (file)

Special Variable: *root*

This variable holds a directory pathname that points to the "root" of the Maiden installation.

The root should mainly be used for storage of runtime
fragments such as configuration, cache, and so forth.

Package

maiden

Source

toolkit.lisp (file)


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

5.1.2 Macros

Macro: define-consumer NAME DIRECT-SUPERCLASSES DIRECT-SLOTS &rest OPTIONS

Shorthand to define a consumer class.

This is like CL:DEFCLASS, with the appropriate superclass and metaclass injected for you. It also makes sure that the class definition is available during compile-time as well.

See CONSUMER
See CONSUMER-CLASS

Package

maiden

Source

consumer.lisp (file)

Macro: define-event NAME DIRECT-SUPERCLASSES DIRECT-SLOTS &rest OPTIONS

Shorthand macro to define an event class.

This takes care of potentially injecting the EVENT superclass and setting the necessary EVENT-CLASS metaclass. Otherwise it is identical to CL:DEFCLASS.

See CL:DEFCLASS
See EVENT
See EVENT-CLASS

Package

maiden

Source

event.lisp (file)

Macro: define-function-handler (CONSUMER NAME &optional EVENT-TYPE) ARGS &body BODY

Shorthand macro to define an event an a corresponding handler in one go.

Special body options are extracted to provide further control over the definition of the event:
:SUPERCLASSES The superclass list to use.
:EXTRA-SLOTS A list of extra slot definitions.
:CLASS-OPTIONS A list of extra class options.
:DOCUMENTATION The docstring to use for the class.
:ADVICE The advice value to use for the event.
Note that these options will NOT be passed on to the DEFINE-HANDLER form.

The ARGS are used both for the arguments to DEFINE-HANDLER and as slot definitions by way of SLOT-ARGS->SLOTS.

See SLOT-ARGS->SLOTS
See DEFINE-EVENT
See DEFINE-HANDLER
See REMOVE-FUNCTION-HANDLER

Package

maiden

Source

consumer.lisp (file)

Macro: define-handler (CONSUMER NAME EVENT-TYPE) ARGS &body BODY

Defines a new handler on the consumer class.

CONSUMER must be the class-name of the consumer to define on. NAME must be a symbol denoting the name of the handler definition. Note that this name will not be carried over to actual handler instances, as they would otherwise clash on multiple consumer instances on the same core. EVENT-TYPE must be a base class for all events that the handler will receive.
ARGS must be a list of arguments, of which the first two will be bound to the consumer instance and the event respectively. The rest of the arguments denote fuzzy slot bindings of the event.
BODY a number of extra handler definition options as a plist followed directly by a number of forms to evaluate upon receiving an event.

The body options are evaluated and passed as class initargs to the resulting handler instance once one is constructed. Note that as such the values will be shared across all instances of the handler defined here. Also note that there are three options which are exempt from this and play special roles:

:DELIVERY-FUNCTION This option is already provided by default. Supplying it manually will mean that the body forms of the DEFINE-HANDLER will be ignored. :MATCH-CONSUMER Should be a slot name of the event that needs to match the consumer for the event to be handled. You’ll want to use this option for handlers of clients, in order to ensure that the handler from the client instance that matches the client the event is intended for is called. :ADD-TO-CONSUMER By default T; decides whether the resulting handler instances should be added to the consumer directly, or to the cores the consumer is added to.

In effect this constructs an appropriate ABSTRACT-HANDLER instance and calls UPDATE-HANDLER with it on the consumer class.

See DEEDS:WITH-FUZZY-SLOT-BINDINGS
See DEEDS:WITH-ORIGIN
See ABSTRACT-HANDLER
See UPDATE-HANDLER
See REMOVE-HANDLER

Package

maiden

Source

consumer.lisp (file)

Macro: define-instruction (CONSUMER INSTRUCTION &optional EVENT-TYPE) ARGS &body BODY

Shorthand macro to define an instruction-like event.

This is essentially the same as DEFINE-FUNCTION-HANDLER with the following additions:
- INSTRUCTION-EVENT is always injected as a superclass.
- A function of the same name as the instruction is generated that creates the appropriate event and sends it off to a core.

This thus allows you to simulate a standard function interface for code that runs over the event-loop. Note that the generated function will not wait for a response to the event and immediately returns. The returned value is the generated event instance.

See DEFINE-FUNCTION-HANDLER
See BROADCAST
See REMOVE-INSTRUCTION

Package

maiden

Source

consumer.lisp (file)

Macro: define-query (CONSUMER INSTRUCTION &optional EVENT-TYPE EVENT-RESPONSE-TYPE) ARGS &body BODY

Shorthand macro to define a query-like event.

This is similar to DEFINE-INSTRUCTION, with the exception that possibly two events (one for issue and one for response) are generated, and that the issue function will await a response and return with the intended return value, thus simulating a complete function API over the event system.

If no explicit EVENT-RESPONSE-TYPE is specified, a generic response event is used instead. See RESPOND.

See RESPOND
See REMOVE-QUERY

Package

maiden

Source

consumer.lisp (file)

Macro: do-issue CORE EVENT-TYPE &rest INITARGS

Shorthand macro to construct and issue an event onto a core.

The event-type should not be quoted.

See DEEDS:DO-ISSUE

Package

maiden

Source

toolkit.lisp (file)

Macro: named-lambda NAME ARGS &body BODY

Attempt to construct a lambda with a name.

Note that standard name clashing rules apply and naming the lambda after a CL function will likely fail if the implementation supports package locks.

Package

maiden

Source

toolkit.lisp (file)

Macro: update-list THING LIST &key KEY TEST

Macro to update the list with a new item.

The item is added to the list if it is not yet contained and updated in-place otherwise.

See MAKE-UPDATED-LIST

Package

maiden

Source

toolkit.lisp (file)

Macro: with-awaiting (CORE EVENT-TYPE) ARGS SETUP-FORM &body BODY

Waits for a response event to arrive on the core before evaluating the body.

This is useful to write event-driven, reactionary code.
The temporary handler to catch the code is added to the
core’s back loop.

Note that CORE can be one of
- CORE The temporary handler is attached to
the core’s block-loop.
- CONSUMER The first core on the client’s list of
cores is used as above.
- DEEDS:EVENT-LOOP The temporary handler is directly
attached to it.

You can also specify a maximum waiting timeout with the
:TIMEOUT body options. The timeout is in seconds. Similar
to DEFINE-HANDLER, you can also specify a :FILTER test
body option.

See DEEDS:WITH-AWAITING

Package

maiden

Source

core.lisp (file)

Macro: with-default-encoding (&optional ENCODING) &body BODY

Evaluate BODY in an environment where the default external format is set to the given encoding.

Only works on:
- SBCL
- CCL

Package

maiden

Source

toolkit.lisp (file)

Macro: with-retry-restart (RESTART FORMAT-STRING &rest FORMAT-ARGS) &body BODY

Evaluates body around which a restart is established that allows retrying the evaluation of the body.

Similar to CL:WITH-SIMPLE-RESTART.

Package

maiden

Source

toolkit.lisp (file)


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

5.1.3 Functions

Function: add-to-core CORE &rest CONSUMERS

Easily add consumers to a core.

The consumers will be started after having been added to the core. Each consumer in the list of consumers can be:

- A symbol denoting the class of consumer to construct - A string or keyword denoting a package that homes a symbol denoting a consumer class.
- A list starting with one of the above followed by the initargs for the class instantiation.

The instances are all constructed before any of them are added to the core or started, so as to catch errors early.

Package

maiden

Source

core.lisp (file)

Function: broadcast CORES EVENT-TYPE &rest INITARGS

Shorthand function to construct and issue an event onto a set of cores.

Unlike DO-ISSUE, this is a function, so the event-type
has to be quoted.

Package

maiden

Source

toolkit.lisp (file)

Function: enlist THING &rest EXTRA-ELEMENTS

If THING is a list, it is returned. Otherwise a new list out of the given elements is constructed.

Package

maiden

Source

toolkit.lisp (file)

Function: find-consumer-in-package PACKAGE

Scans through the symbols in the given package and attempts to find one that denotes a class that is a subclass of CONSUMER.

The first such symbol found is returned.

Package

maiden

Source

toolkit.lisp (file)

Function: format-absolute-time TIME

Formats the universal-time as a timestring in the format of YYYY.MM.DD hh:mm:ss

Package

maiden

Source

toolkit.lisp (file)

Function: format-relative-time SECONDS

Formats the time in seconds as a human-readable string.

Time is split up into seconds, minutes, hours, days, weeks, months, years, decades, centuries, and ├Žons.

Package

maiden

Source

toolkit.lisp (file)

Function: format-time TIME &optional RELATIVE-TIME-THRESHOLD

Formats the universal-time in a (hopefully) appropriate manner.

If the time differs from now by more than the RELATIVE-TIME-THRESHOLD then the time is printed absolutely, otherwise relatively.

See FORMAT-RELATIVE-TIME
See FORMAT-ABSOLUTE-TIME

Package

maiden

Source

toolkit.lisp (file)

Function: get-unix-time ()

Returns the time in seconds since the unix epoch of 1970.

Package

maiden

Source

toolkit.lisp (file)

Function: kw NAME

Return the keyword corresponding to the given symbol designator.

Package

maiden

Source

toolkit.lisp (file)

Function: make-core &rest CONSUMERS

Construct a new core instance and add consumers to it.

The resulting core will be started.

See CORE
See ADD-TO-CORE

Package

maiden

Source

core.lisp (file)

Function: maybe-invoke-debugger CONDITION &optional RESTART &rest VALUES

Might invoke the debugger with the condition.

If *DEBUGGER* is non-NIL, the debugger is invoked with a CONTINUE restart surrounding it to allow giving up on handling the condition. Otherwise, if the RESTART argument is passed, that restart is invoked with the rest of the arguments as values for the restart.

See *DEBUGGER*

Package

maiden

Source

toolkit.lisp (file)

Function: remove-function-handler CONSUMER NAME &optional EVENT-TYPE

Shorthand function to remove a function-handler definition.

This removes both the event class and the handler it defined.

See CL:FIND-CLASS
See REMOVE-HANDLER

Package

maiden

Source

consumer.lisp (file)

Function: remove-handler ABSTRACT-HANDLER CLASS-ISH

Removes the handler from the consumer-class.

This function simply updates the list of direct-handlers on the class by removing the corresponding abstract-handler.

The class-ish can be a CONSUMER-CLASS, a CONSUMER, or a SYMBOL naming a consumer-class.

The abstract-handler can be an ABSTRACT-HANDLER, or a SYMBOL denoting the NAME of an abstract-handler.

See DIRECT-HANDLERS
See ABSTRACT-HANDLER
See CONSUMER-CLASS

Package

maiden

Source

consumer.lisp (file)

Function: remove-instruction CONSUMER INSTRUCTION &optional EVENT-TYPE

Shorthand function to remove an instruction definition.

This removes both the event class, the handler, and the issue- function it defined.

See CL:FMAKUNBOUND
See REMOVE-FUNCTION-HANDLER

Package

maiden

Source

consumer.lisp (file)

Function: remove-query CONSUMER INSTRUCTION &optional EVENT-TYPE EVENT-RESPONSE-TYPE

Shorthand function to remove a query definition.

This removes both the event classes, the handler, and the issue- function it defined.

See REMOVE-FUNCTION-HANDLER
See CL:FIND-CLASS
See CL:FMAKUNBOUND

Package

maiden

Source

consumer.lisp (file)

Function: starts-with START SEQUENCE &key TEST

Returns true if SEQUENCE begins with START.

Package

maiden

Source

toolkit.lisp (file)

Function: universal-to-unix UNIVERSAL

Convert universal-time to unix-time.

Package

maiden

Source

toolkit.lisp (file)

Function: unix-to-universal UNIX

Convert unix-time to universal-time.

Package

maiden

Source

toolkit.lisp (file)

Function: unlist THING &key KEY

If THING is not a list, it is returned. Otherwise the element by KEY from the list is returned.

Package

maiden

Source

toolkit.lisp (file)

Function: xnor A B

If both A and B are either true or false at the same time.

Package

maiden

Source

toolkit.lisp (file)

Function: xor A B

If either A or B are true, but not both.

Package

maiden

Source

toolkit.lisp (file)


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

5.1.4 Generic functions

Generic Function: add-consumer CONSUMER TARGET

Add the consumer to the core.

If the consumer already exists on the core, nothing is done. If a consumer of the same name already exists on the core, a warning of type CONSUMER-NAME-DUPLICATED-WARNING is signalled.

If a consumer has been added, an event of type CONSUMER-ADDED is issued onto the core.

See CONSUMER-NAME-DUPLICATED-WARNING
See CONSUMER-ADDED

Package

maiden

Source

core.lisp (file)

Methods
Method: add-consumer (AGENT agent) (CORE core) before
Source

agent.lisp (file)

Method: add-consumer (CONSUMER consumer) (CORE core)
Method: add-consumer CONSUMER (TARGETS list)
Method: add-consumer (CONSUMERS list) TARGET
Method: add-consumer CONSUMER TARGET around
Method: add-consumer (CONSUMER consumer) (CORE core) after
Source

consumer.lisp (file)

Generic Function: add-to-consumer OBJECT

Whether the generated handler of this abstract handler should be added to the consumer or the cores of the consumer.

See ABSTRACT-HANDLER

Package

maiden

Writer

(setf add-to-consumer) (generic function)

Methods
Method: add-to-consumer (ABSTRACT-HANDLER abstract-handler)

automatically generated reader method

Source

consumer.lisp (file)

Generic Function: (setf add-to-consumer) NEW-VALUE OBJECT
Package

maiden

Reader

add-to-consumer (generic function)

Methods
Method: (setf add-to-consumer) NEW-VALUE (ABSTRACT-HANDLER abstract-handler)

automatically generated writer method

Source

consumer.lisp (file)

Generic Function: advice OBJECT

Accessor to the advice information on the event or event-class.

See EVENT-CLASS
See EVENT

Package

maiden

Writer

(setf advice) (generic function)

Methods
Method: advice (EVENT event)
Source

event.lisp (file)

Method: advice (EVENT-CLASS event-class)

automatically generated reader method

Source

event.lisp (file)

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

maiden

Reader

advice (generic function)

Methods
Method: (setf advice) NEW-VALUE (EVENT-CLASS event-class)

automatically generated writer method

Source

event.lisp (file)

Generic Function: agent CONDITION

Accessor to the agent that this object holds.

See AGENT-CONDITION

Package

maiden

Methods
Method: agent (CONDITION agent-condition)
Source

conditions.lisp (file)

Generic Function: block-loop OBJECT

Accessor to the blocking back loop of the Maiden core.

This should govern one-time handlers and response events.

See CORE

Package

maiden

Writer

(setf block-loop) (generic function)

Methods
Method: block-loop (CORE core)

automatically generated reader method

Source

core.lisp (file)

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

maiden

Reader

block-loop (generic function)

Methods
Method: (setf block-loop) NEW-VALUE (CORE core)

automatically generated writer method

Source

core.lisp (file)

Generic Function: client CONDITION

Accessor to the client that this object holds.

See CLIENT-CONDITION

Package

maiden

Methods
Method: client (CLIENT-EVENT client-event)

automatically generated reader method

Source

standard-events.lisp (file)

Method: client (CONDITION client-condition)
Source

conditions.lisp (file)

Generic Function: consumer ID TARGET

Retrieve a consumer from the core.

If no consumer that matches the ID is found, NIL is returned.

See MATCHES

Package

maiden

Source

core.lisp (file)

Methods
Method: consumer ID (CORES list)
Method: consumer ID (CORE core)
Generic Function: consumers OBJECT

Accessor to the list of consumers associated with the core.

See CONSUMER
See CORE

Package

maiden

Writer

(setf consumers) (generic function)

Methods
Method: consumers (CORE core)

automatically generated reader method

Source

core.lisp (file)

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

maiden

Reader

consumers (generic function)

Methods
Method: (setf consumers) NEW-VALUE (CORE core)

automatically generated writer method

Source

core.lisp (file)

Generic Function: core CONDITION

Accessor to the core that this object holds.

See CORE-CONDITION

Package

maiden

Methods
Method: core (EVENT event)
Source

event.lisp (file)

Method: core (CONDITION core-condition)
Source

conditions.lisp (file)

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

maiden

Methods
Method: core-handlers (CONSUMER consumer)

automatically generated reader method

Source

consumer.lisp (file)

Method: (setf core-handlers) NEW-VALUE (CONSUMER consumer)

automatically generated writer method

Source

consumer.lisp (file)

Generic Function: cores OBJECT

Accessor to the list of cores the consumer is currently registered with.

See CONSUMER

Package

maiden

Writer

(setf cores) (generic function)

Methods
Method: cores (CONSUMER consumer)

automatically generated reader method

Source

consumer.lisp (file)

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

maiden

Reader

cores (generic function)

Methods
Method: (setf cores) NEW-VALUE (CONSUMER consumer)

automatically generated writer method

Source

consumer.lisp (file)

Generic Function: data OBJECT

Accessor to the data storage container for the data entity.

See DATA-ENTITY
See DATA-VALUE

Package

maiden

Writer

(setf data) (generic function)

Methods
Method: data (DATA-ENTITY data-entity)

automatically generated reader method

Source

entity.lisp (file)

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

maiden

Reader

data (generic function)

Methods
Method: (setf data) NEW-VALUE (DATA-ENTITY data-entity)

automatically generated writer method

Source

entity.lisp (file)

Generic Function: data-value FIELD ENTITY

Accessor for a single data field in the data entity.

See DATA
See DATA-ENTITY

Package

maiden

Writer

(setf data-value) (generic function)

Methods
Method: data-value FIELD (ENTITY data-entity)
Source

entity.lisp (file)

Generic Function: (setf data-value) VALUE FIELD ENTITY
Package

maiden

Reader

data-value (generic function)

Methods
Method: (setf data-value) VALUE FIELD (ENTITY data-entity)
Source

entity.lisp (file)

Generic Function: direct-handlers OBJECT

Accessor to the list of direct handler definitions on the consumer class.

This only holds handler definitions that have been defined for
this specific class directly.
Also note that the handler objects contained in this list are
only abstract-handler instances and cannot be directly used as handlers.

When this place is set, the consumer-class’ inheritance is
finalized.

See CONSUMER-CLASS
See ABSTRACT-HANDLER
See MOP:FINALIZE-INHERITANCE

Package

maiden

Writer

(setf direct-handlers) (generic function)

Methods
Method: direct-handlers (CONSUMER-CLASS consumer-class)

automatically generated reader method

Source

consumer.lisp (file)

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

maiden

Reader

direct-handlers (generic function)

Methods
Method: (setf direct-handlers) NEW-VALUE (CONSUMER-CLASS consumer-class)

automatically generated writer method

Source

consumer.lisp (file)

Method: (setf direct-handlers) HANDLERS (CLASS consumer-class) after
Source

consumer.lisp (file)

Generic Function: effective-handlers OBJECT

Accessor to the list of effective handler definitions on the consumer class.

This holds all handler definitions, including inherited ones.
Note that the handler objects contained in this list are only abstract-handler instances and cannot be directly used as
handlers.

When this place is set, the list of INSTANCES is updated and
each existing instance is reinitialised through REINITIALIZE-
HANDLERS.

See CONSUMER-CLASS
See ABSTRACT-HANDLER
See INSTANCES
See REINITIALIZE-HANDLERS

Package

maiden

Writer

(setf effective-handlers) (generic function)

Methods
Method: effective-handlers (CONSUMER-CLASS consumer-class)

automatically generated reader method

Source

consumer.lisp (file)

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

maiden

Reader

effective-handlers (generic function)

Methods
Method: (setf effective-handlers) NEW-VALUE (CONSUMER-CLASS consumer-class)

automatically generated writer method

Source

consumer.lisp (file)

Method: (setf effective-handlers) HANDLERS (CLASS consumer-class) after
Source

consumer.lisp (file)

Generic Function: existing-agent CONDITION

Reader for the agent that already exists on the core.

See AGENT-ALREADY-EXISTS-ERROR

Package

maiden

Methods
Method: existing-agent (CONDITION agent-already-exists-error)
Source

conditions.lisp (file)

Generic Function: existing-consumer CONDITION

Reader for the consumer that previously already existed on the core.

See CONSUMER-NAME-DUPLICATED-WARNING

Package

maiden

Methods
Method: existing-consumer (CONDITION consumer-name-duplicated-warning)
Source

conditions.lisp (file)

Generic Function: id OBJECT

Accessor to the IDentity of an entity.

By default this is initialised to a fresh UUIDv4 string.

See ENTITY

Package

maiden

Writer

(setf id) (generic function)

Methods
Method: id (ENTITY entity)

automatically generated reader method

Source

entity.lisp (file)

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

maiden

Reader

id (generic function)

Methods
Method: (setf id) NEW-VALUE (ENTITY entity)

automatically generated writer method

Source

entity.lisp (file)

Generic Function: instances OBJECT

Accessor to the list of weak-pointers to consumer instances.

The elements in the list are instances of TG:WEAK-POINTER and may point to instances of the consumer class. This list is necessary to keep track of and properly synchronise the handlers upon redefinition.

This list is updated whenever a new CONSUMER instance is created or when EFFECTIVE-HANDLERS of its class is set.

See TG:WEAK-POINTER
See CONSUMER

Package

maiden

Writer

(setf instances) (generic function)

Methods
Method: instances (CONSUMER-CLASS consumer-class)

automatically generated reader method

Source

consumer.lisp (file)

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

maiden

Reader

instances (generic function)

Methods
Method: (setf instances) NEW-VALUE (CONSUMER-CLASS consumer-class)

automatically generated writer method

Source

consumer.lisp (file)

Generic Function: instantiate-handler HANDLER CONSUMER

This function creates an actual handler instance from the abstract handler definition.

The instantiation proceeds as follows:
1. The options :FILTER, :DELIVERY-FUNCTION, and :MATCH-CONSUMER
are extracted from the options list.
2. If :MATCH-CONSUMER is given and is eql to T, then the :FILTER
option is extended by surrounding it as follows:
(and (eq ,consumer consumer) ..)
where ,consumer denotes the consumer instance passed to
instantiate-handler.
3. If :MATCH-CONSUMER is given and is not eql to T, then the :FILTER
option is extended by surrounding it as follows:
(and (eq ,consumer ,match-consumer) ..)
where ,consumer is as above and ,match-consumer is the value of
the :MATCH-CONSUMER option.
4. MAKE-INSTANCE is called with the TARGET-CLASS of the abstract
handler, a :delivery-function initarg that is a function that
calls the :DELIVERY-FUNCTION extracted from the option with the
consumer and the event, a :filter initarg that is the value of
the :FILTER option, and the rest of the OPTIONS of the abstract
handler.

See ABSTRACT-HANDLER

Package

maiden

Methods
Method: instantiate-handler (HANDLER abstract-handler) (CONSUMER consumer)
Source

consumer.lisp (file)

Generic Function: lock OBJECT

Accessor to the lock that is used to synchronise access to this object.

See CONSUMER

Package

maiden

Writer

(setf lock) (generic function)

Methods
Method: lock (CONSUMER consumer)

automatically generated reader method

Source

consumer.lisp (file)

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

maiden

Reader

lock (generic function)

Methods
Method: (setf lock) NEW-VALUE (CONSUMER consumer)

automatically generated writer method

Source

consumer.lisp (file)

Generic Function: matches A B

Generic comparator operator.

This compares in a potentially ambiguous "dwim" sense. Various components in the system add methods to make the matching work as much as expected as possible.

Package

maiden

Source

entity.lisp (file)

Methods
Method: matches (A symbol) (B agent)
Source

agent.lisp (file)

Method: matches (A agent) (B symbol)
Source

agent.lisp (file)

Method: matches (A agent) (B agent)
Source

agent.lisp (file)

Method: matches (ENTITY named-entity) B
Method: matches A (ENTITY entity)
Method: matches (ENTITY entity) B
Method: matches (A entity) (B entity)
Method: matches (A vector) (B vector)
Method: matches (A string) (B string)
Method: matches (A list) (B list)
Method: matches (A uuid) (B string)
Method: matches (A uuid) (B vector)
Method: matches A (UUID uuid)
Method: matches (A uuid) (B uuid)
Method: matches A B
Generic Function: new-consumer CONDITION

Reader for the new consumer that is being added to the core.

See CONSUMER-NAME-DUPLICATED-WARNING

Package

maiden

Methods
Method: new-consumer (CONDITION consumer-name-duplicated-warning)
Source

conditions.lisp (file)

Generic Function: options OBJECT

Accessor to the list of initargs that the handler should receive upon instantiation.

See ABSTRACT-HANDLER

Package

maiden

Writer

(setf options) (generic function)

Methods
Method: options (ABSTRACT-HANDLER abstract-handler)

automatically generated reader method

Source

consumer.lisp (file)

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

maiden

Reader

options (generic function)

Methods
Method: (setf options) NEW-VALUE (ABSTRACT-HANDLER abstract-handler)

automatically generated writer method

Source

consumer.lisp (file)

Generic Function: primary-loop OBJECT

Accessor to the primary loop of the Maiden core.

This should take care of the bulk of handlers and events.

See CORE

Package

maiden

Writer

(setf primary-loop) (generic function)

Methods
Method: primary-loop (CORE core)

automatically generated reader method

Source

core.lisp (file)

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

maiden

Reader

primary-loop (generic function)

Methods
Method: (setf primary-loop) NEW-VALUE (CORE core)

automatically generated writer method

Source

core.lisp (file)

Generic Function: remove-consumer CONSUMER TARGET

Remove the consumer from the core.

If the consumer doesn’t exist on the core, nothing is done. Otherwise the consumer is removed from the core’s list.

If a consumer has been removed, an event of type CONSUMER- REMOVED is issued onto the core.

See CONSUMER-REMOVED

Package

maiden

Source

core.lisp (file)

Methods
Method: remove-consumer ID (CORE core)
Method: remove-consumer CONSUMER (TARGETS list)
Method: remove-consumer (CONSUMERS list) TARGET
Method: remove-consumer CONSUMER TARGET around
Method: remove-consumer (CONSUMER consumer) (CORE core) after
Source

consumer.lisp (file)

Method: remove-consumer (CONSUMER consumer) (EVERYWHERE (eql t))
Source

consumer.lisp (file)

Generic Function: respond EVENT &rest ARGS &key CLASS PAYLOAD &allow-other-keys

Respond to the event in an appropriate way.

The response event will be issued on to the same core that the event being responded to was issued to. If the event does not have a specific response event already (through a specialised method on RESPOND), then you may specify the class to use with the :CLASS initarg.

Package

maiden

Source

standard-events.lisp (file)

Methods
Method: respond (EVENT query-event) &key PAYLOAD
Method: respond (EVENT event) &rest ARGS &key CLASS &allow-other-keys
Method: respond (EVENT client-event) &rest ARGS &key CLASS &allow-other-keys
Generic Function: target-class OBJECT

Accessor to the target class that the actual handler should be of when the abstract-handler is instantiated.

Defaults to DEEDS:QUEUED-HANDLER

See ABSTRACT-HANDLER
See DEEDS:QUEUED-HANDLER

Package

maiden

Writer

(setf target-class) (generic function)

Methods
Method: target-class (ABSTRACT-HANDLER abstract-handler)

automatically generated reader method

Source

consumer.lisp (file)

Generic Function: (setf target-class) NEW-VALUE OBJECT
Package

maiden

Reader

target-class (generic function)

Methods
Method: (setf target-class) NEW-VALUE (ABSTRACT-HANDLER abstract-handler)

automatically generated writer method

Source

consumer.lisp (file)


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

5.1.5 Conditions

Condition: agent-already-exists-error ()

A condition signalled when an agent of the same name already exists on the core.

See EXISTING-AGENT
See AGENT-CONDITION
See CORE-CONDITION

Package

maiden

Source

conditions.lisp (file)

Direct superclasses
Direct methods

existing-agent (method)

Direct slots
Slot: existing-agent
Initargs

:existing-agent

Readers

existing-agent (generic function)

Direct Default Initargs
InitargValue
:existing-agent(error "existing-agent required.")
Condition: agent-condition ()

Superclass for all conditions related to agents.

See AGENT
See MAIDEN-CONDITION

Package

maiden

Source

conditions.lisp (file)

Direct superclasses

maiden-condition (condition)

Direct subclasses

agent-already-exists-error (condition)

Direct methods

agent (method)

Direct slots
Slot: agent
Initargs

:agent

Readers

agent (generic function)

Direct Default Initargs
InitargValue
:agent(error "agent required.")
Condition: client-condition ()

Superclass for all conditions related to clients.

See CLIENT
See MAIDEN-CONDITION

Package

maiden

Source

conditions.lisp (file)

Direct superclasses

maiden-condition (condition)

Direct methods

client (method)

Direct slots
Slot: client
Initargs

:client

Readers

client (generic function)

Direct Default Initargs
InitargValue
:client(error "client required.")
Condition: consumer-name-duplicated-warning ()

A condition signalled when a consumer is added to a core and has the same name as an already existing consumer.

See EXISTING-CONSUMER
See NEW-CONSUMER
See CORE-CONDITION

Package

maiden

Source

conditions.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: existing-consumer
Initargs

:existing-consumer

Readers

existing-consumer (generic function)

Slot: new-consumer
Initargs

:new-consumer

Readers

new-consumer (generic function)

Direct Default Initargs
InitargValue
:new-consumer(error "new-consumer required.")
:existing-consumer(error "existing-consumer required.")
Condition: core-condition ()

Superclass for all conditions related to operations on a core.

See CORE
See MAIDEN-CONDITION

Package

maiden

Source

conditions.lisp (file)

Direct superclasses

maiden-condition (condition)

Direct subclasses
Direct methods

core (method)

Direct slots
Slot: core
Initargs

:core

Readers

core (generic function)

Direct Default Initargs
InitargValue
:core(error "core required.")
Condition: maiden-condition ()

Superclass for all condition types in the Maiden system.

Package

maiden

Source

conditions.lisp (file)

Direct superclasses

condition (condition)

Direct subclasses

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

5.1.6 Classes

Class: abstract-handler ()

This is an object to represent a handler definition. It contains all data necessary to construct an appropriate handler instance for a consumer.

See ADD-TO-CONSUMER
See TARGET-CLASS
See OPTIONS
See INSTANTIATE-HANDLER
See DEFINE-HANDLER

Package

maiden

Source

consumer.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: target-class
Initform

(quote deeds:locally-blocking-handler)

Readers

target-class (generic function)

Writers

(setf target-class) (generic function)

Slot: add-to-consumer
Initargs

:add-to-consumer

Readers

add-to-consumer (generic function)

Writers

(setf add-to-consumer) (generic function)

Slot: options
Initargs

:options

Readers

options (generic function)

Writers

(setf options) (generic function)

Slot: name
Initargs

:name

Readers

name (generic function)

Writers

(setf name) (generic function)

Direct Default Initargs
InitargValue
:optionsnil
:add-to-consumert
Class: active-event ()

Superclass for all active events in the system.

An active event notifies of a request for an action to be taken somewhere in the system. It is active in the sense that it should cause some part of the system to perform an action, rather than merely notifying of a change happening.

See EVENT
See PASSIVE-EVENT

Package

maiden

Source

standard-events.lisp (file)

Direct superclasses

event (class)

Direct subclasses

instruction-event (class)

Class: agent ()

A type of consumer of which only one instance should exist on a core.

An agent’s name defaults to the agent’s class name.

An agent MATCHES if the class or the class name matches.

If an agent is attempted to be added to a core when an
agent that matches it by name already exists on the core,
a warning of type AGENT-ALREADY-EXISTS-ERROR is signalled.

See CONSUMER

Package

maiden

Source

agent.lisp (file)

Direct superclasses

consumer (class)

Direct methods
Class: block-loop ()

Base class for the block loop on a Maiden core.

See CORE
See DEEDS:EVENT-LOOP

Package

maiden

Source

core.lisp (file)

Direct superclasses

event-loop (class)

Class: client ()

A type of consumer of which multiple instances can exist on a core.

See CONSUMER

Package

maiden

Source

client.lisp (file)

Direct superclasses

consumer (class)

Class: client-event ()

Superclass for all events that relate to a client.

This event holds the client it relates to in a slot.

See CLIENT
See EVENT

Package

maiden

Source

standard-events.lisp (file)

Direct superclasses

event (class)

Direct methods
Direct slots
Slot: client
Initargs

:client

Readers

client (generic function)

Direct Default Initargs
InitargValue
:client(error "client required.")
Class: consumer ()

Superclass for all consumers on a core.

Consumers are responsible for issuing and responding to events that happen on a core. They do this by having a number of handler definitions tied to them, which are instantiated into proper handlers for each consumer instance. Consumers can have handlers that are registered directly on the consumer or are instead added to the core the consumer is being added to. The former allows the grouping of handlers and a more granular management of resources, whereas the latter allows you to circumvent potential bottleneck or ordering issues. See the Deeds library for information on how the event-loop and handlers work in detail.

Consumers are divided into two classes, ones of which only a single instance should exist on the core, and ones of which many may exist on the core. The former are called AGENTS, and the latter are called CLIENTS. The former usually provide functionality that is reactionary in some sense. The latter usually provide some form of connection to another entity and primarily provide events rather than consuming them. You should not inherit directly from CONSUMER therefore, and rather pick either CLIENT or AGENT, depending on which of the two is more suitable for the kind of consumer you want to write for the system.

Consumer classes must inherit from the CONSUMER-CLASS class, which is responsible for ensuring that handler definitions get properly instantiated and managed over consumer instances.

In order to easily define consumer classes with the appropriate superclass and metaclass, you can use DEFINE-CONSUMER.

In order to add handlers to the consumer, use DEFINE-HANDLER.

Each consumer has a LOCK that can be used to synchronise access to the consumer from different parts in the system. Since Deeds, and Maiden by extension, is highly parallel most of the time, locking of resources and access to the consumer from different handlers is vital.

The list of handler instances is held in the HANDLERS slot. The list of handlers that are tied directly to cores is held in the CORE-HANDLERS slot. The list of cores the consumer is on is held in the CORES slot.

You can start and stop all the handlers on a consumer by the usual Deeds START and STOP functions.

After the initialisation of a consumer, the consumer instance is pushed onto the INSTANCES list of its class by way of a weak-pointer. It will also turn all of its effective-handlers into actual handler instances by way of INSTANTIATE-HANDLER and push them onto its HANDLERS list.

See NAMED-ENTITY
See COMPILED-EVENT-LOOP
See HANDLER
See CONSUMER-CLASS
See AGENT
See CLIENT
See DEFINE-CONSUMER
See DEFINE-HANDLER
See HANDLERS
See CORE-HANDLERS
See CORES
See LOCK
See START
See STOP
See INSTANCES
See INSTANTIATE-HANDLER

Package

maiden

Source

consumer.lisp (file)

Direct superclasses
  • handler (class)
  • compiled-event-loop (class)
  • named-entity (class)
Direct subclasses
Direct methods
Direct slots
Slot: cores
Readers

cores (generic function)

Writers

(setf cores) (generic function)

Slot: core-handlers
Readers

core-handlers (generic function)

Writers

(setf core-handlers) (generic function)

Slot: event-loop-lock
Readers

lock (generic function)

Writers

(setf lock) (generic function)

Class: consumer-added ()

Event that is issued after a consumer has been added to the core.

See CORE-EVENT
See CONSUMER

Package

maiden

Source

standard-events.lisp (file)

Direct superclasses
Direct methods

print-object (method)

Direct slots
Slot: consumer
Initargs

:consumer

Direct Default Initargs
InitargValue
:consumer(error "consumer required.")
Class: consumer-class ()

Metaclass for all consumer objects.

It handles the proper instantiation of handler objects when the consumer is added to a core or the handler definitions are updated.

See DIRECT-HANDLERS
See EFFECTIVE-HANDLERS
See INSTANCES
See CONSUMER

Package

maiden

Source

consumer.lisp (file)

Direct superclasses

standard-class (class)

Direct methods
Direct slots
Slot: direct-handlers
Readers

direct-handlers (generic function)

Writers

(setf direct-handlers) (generic function)

Slot: effective-handlers
Readers

effective-handlers (generic function)

Writers

(setf effective-handlers) (generic function)

Slot: instances
Readers

instances (generic function)

Writers

(setf instances) (generic function)

Class: consumer-removed ()

Event that is issued after a consumer has been removed from the core.

See CORE-EVENT
See CONSUMER

Package

maiden

Source

standard-events.lisp (file)

Direct superclasses
Direct methods

print-object (method)

Direct slots
Slot: consumer
Initargs

:consumer

Direct Default Initargs
InitargValue
:consumer(error "consumer required.")
Class: core ()

The core of an event system in Maiden.

The core is responsible for managing events, consumers, and their handlers. It uses two (!) event-loops in the back to handle event delivery. The first loop, called the primary loop is where most handlers live. It is (by default) of type PRIMARY-LOOP and should be fairly speed in delivery, at the cost that adding and removing handlers will be slow. The second loop, called the blocking loop is where temporary handlers that only exist for hopefully a short time live. It is (by default) of type BLOCK-LOOP and is not optimised for fast delivery, but much faster at removing and adding handlers. Thus, whenever you wait for an event for a one-time request, the handler should be added to the block loop.

Calling DE/REGISTER-HANDLER on a core will automatically add it to the primary loop. If you want to change the blocking loop you will have to access it directly.

When an event is ISSUEd onto the core, it is ISSUEd onto the primary loop and then ISSUEd onto the block loop. The behaviour for when an event is directly HANDLEd by the core is analogous.

See PRIMARY-LOOP
See BLOCK-LOOP
See CONSUMERS
See CONSUMER
See ADD-CONSUMER
See REMOVE-CONSUMER
See START
See STOP
See ISSUE
See HANDLE
See WITH-AWAITING
See WITH-RESPONSE
See MAKE-CORE
See ADD-TO-CORE

Package

maiden

Source

core.lisp (file)

Direct superclasses

named-entity (class)

Direct methods
Direct slots
Slot: primary-loop
Initargs

:primary-loop

Readers

primary-loop (generic function)

Writers

(setf primary-loop) (generic function)

Slot: block-loop
Initargs

:block-loop

Readers

block-loop (generic function)

Writers

(setf block-loop) (generic function)

Slot: consumers
Readers

consumers (generic function)

Writers

(setf consumers) (generic function)

Direct Default Initargs
InitargValue
:primary-loop(make-instance (quote maiden:primary-loop))
:block-loop(make-instance (quote maiden:block-loop))
Class: core-event ()

Superclass for all events relating to a Maiden core.

See EVENT

Package

maiden

Source

standard-events.lisp (file)

Direct superclasses

event (class)

Direct subclasses
Class: data-entity ()

Superclass for entities that have a data storage table.

See ENTITY
See DATA
See DATA-VALUE

Package

maiden

Source

entity.lisp (file)

Direct superclasses

entity (class)

Direct methods
Direct slots
Slot: data
Initform

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

Readers

data (generic function)

Writers

(setf data) (generic function)

Class: entity ()

Superclass for things that are comparable according to some kind of identity.

See ID

Package

maiden

Source

entity.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: id
Initargs

:id

Readers

id (generic function)

Writers

(setf id) (generic function)

Direct Default Initargs
InitargValue
:id(princ-to-string (uuid:make-v4-uuid))
Class: event ()

The superclass for all events in Maiden.

An event is an object that represents a change that occurs in the system. It may also carry relevant information about the change. Events can also be used to signify requests for things to happen in the system.

Events need to be ISSUEd onto a core, where they will then be dispatched to HANDLERs that can process it.

See EVENT-CLASS
See CORE
See DEEDS:EVENT
See DEFINE-EVENT

Package

maiden

Source

event.lisp (file)

Direct superclasses

event (class)

Direct subclasses
Direct methods
  • handle (method)
  • handle (method)
  • issue (method)
  • issue (method)
  • respond (method)
  • core (method)
  • advice (method)
Class: instruction-event ()

Superclass for all instruction events in the system.

Instructions are event representations of a change request in the system. They often represent a "virtual" function call.

See DEFINE-INSTRUCTION
See ACTIVE-EVENT

Package

maiden

Source

standard-events.lisp (file)

Direct superclasses

active-event (class)

Direct subclasses

query-event (class)

Class: named-entity ()

An entity with a human-readable name attached to it.

See ENTITY
See NAME

Package

maiden

Source

entity.lisp (file)

Direct superclasses

entity (class)

Direct subclasses
Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name (generic function)

Writers

(setf name) (generic function)

Direct Default Initargs
InitargValue
:namenil
Class: passive-event ()

Superclass for all passive events in the system.

A passive event notifies of a change that happened somewhere in the system. It is passive in the sense that it provides information, rather than explicitly requesting information or explicitly requesting an action.

See EVENT
See ACTIVE-EVENT

Package

maiden

Source

standard-events.lisp (file)

Direct superclasses

event (class)

Direct subclasses
Class: primary-loop ()

Base class for the primary loop on a Maiden core.

See CORE
See DEEDS:COMPILED-EVENT-LOOP

Package

maiden

Source

core.lisp (file)

Direct superclasses

compiled-event-loop (class)

Class: query-event ()

Superclass for all query events in the system.

Queries are events that represent both a change request and a request for a result to be obtained about the change. They often represent a "full" function call.

It is identified so that it and its response event counter- piece can be found.

See DEFINE-QUERY
See DEEDS:IDENTIFIED-EVENT
See INSTRUCTION-EVENT

Package

maiden

Source

standard-events.lisp (file)

Direct superclasses
Direct methods

respond (method)


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

5.2 Internal definitions


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

5.2.1 Special variables

Special Variable: *unix-epoch-difference*

The difference in seconds between universal-time and unix-time.

Package

maiden

Source

toolkit.lisp (file)


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

5.2.2 Functions

Function: args->initargs ARGS

Converts a lambda-list into a plist to pass as initargs.

More specifically, each variable in the lambda list will be turned into a key-value pair where the key is the keyword corresponding to the symbol name, followed by the symbol itself.

Package

maiden

Source

consumer.lisp (file)

Function: cascade-handler-changes CLASS

This function computes the effective handlers list for the class and cascades the update downwards in the hierarchy.

Only subclasses that are a subclass of CONSUMER-CLASS and have
been finalized are cascaded.

The EFFECTIVE-HANDLERS list is updated as part of this.

See CONSUMER-CLASS
See EFFECTIVE-HANDLERS

Package

maiden

Source

consumer.lisp (file)

Function: make-updated-list THING LIST KEY TEST

Construct an updated version of LIST where THING is either updated from its old value, or added to it.

The elements in the list are passed through KEY and then
compared against THING using the TEST function.

Package

maiden

Source

toolkit.lisp (file)

Function: slot-args->args ARGS

Converts a list of slot arguments into a lambda list.

See SLOT-ARGS->SLOTS

Package

maiden

Source

consumer.lisp (file)

Function: slot-args->slots ARGS

Converts a list of slot arguments into slot definitions.

The slot-args must be structured like a special kind of lambda-list:

SLOT-ARGS ::= REQ* (&optional OPT*)? (&REST REQ)? (&key OPT*)? REQ ::= name | (name SLOT-INITARG*)
OPT ::= name | (name default-value? SLOT-INITARG*) SLOT-INITARG ::= keyword value

In short:
There are no provided-p predicate variables for optional arguments, but each argument can be followed by a list of possible slot initargs if it is given as a list.

Each returned slot will also automatically receive an initarg of the same name as the slot, but from the keyword package.

Package

maiden

Source

consumer.lisp (file)

Function: swank-connected-p ()
Package

maiden

Source

toolkit.lisp (file)

Function: update-handler ABSTRACT-HANDLER CLASS-ISH

This function is responsible for handling the redefinition of a handler on a consumer-class.

This function simply updates the list of direct-handlers
on the class by replacing the corresponding abstract-handler
or adding it to it.

The class-ish can be a CONSUMER-CLASS, a CONSUMER, or a
SYMBOL naming a consumer-class.

See DIRECT-HANDLERS
See ABSTRACT-HANDLER
See CONSUMER-CLASS

Package

maiden

Source

consumer.lisp (file)

Function: update-root-for-image ()

This function attempts to update the *ROOT* to the current location of the image.

See UIOP:ARGV0

Package

maiden

Source

toolkit.lisp (file)


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

5.2.3 Generic functions

Generic Function: direct-advice OBJECT

Accessor to the advice information that was defined directly on the class.

See EVENT-CLASS

Package

maiden

Writer

(setf direct-advice) (generic function)

Methods
Method: direct-advice (EVENT-CLASS event-class)

automatically generated reader method

Source

event.lisp (file)

Generic Function: (setf direct-advice) NEW-VALUE OBJECT
Package

maiden

Reader

direct-advice (generic function)

Methods
Method: (setf direct-advice) NEW-VALUE (EVENT-CLASS event-class)

automatically generated writer method

Source

event.lisp (file)

Generic Function: find-entity ID PLACE

Attempt to find an entity in a container.

The ID must be matched against each entity in the container by MATCHES.

See ENTITY
See MATCHES

Package

maiden

Source

entity.lisp (file)

Methods
Method: find-entity ID (CORE core)
Source

core.lisp (file)

Method: find-entity ID (CONSUMER consumer)
Source

consumer.lisp (file)

Method: find-entity ID (LIST list)
Method: find-entity ID (ENTITY named-entity)
Generic Function: reinitialize-handlers CONSUMER HANDLERS

This handles the updating of handler definitions on a consumer.

The procedure is as follows:
1. All direct handlers are deregistered from the consumer.
2. New direct handlers are instantiated, started, and registered on the consumer.
3. The old direct handlers are stopped.
4. All core handlers are deregistered from all cores of the consumer. 5. New core handlers are instantiated, started, and registered on the cores.
6. The old core handlers are stopped.

See CONSUMER
See INSTANTIATE-HANDLER
See HANDLERS

Package

maiden

Methods
Method: reinitialize-handlers (CONSUMER consumer) ABSTRACT-HANDLERS
Source

consumer.lisp (file)

Method: reinitialize-handlers (CONSUMER consumer) HANDLERS around
Source

consumer.lisp (file)


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

5.2.4 Classes

Class: event-class ()

Metaclass for events.

In addition to the effects inherited from DEEDS:EVENT-CLASS, this class ads so-called "advice". Advice denotes advisory information about the event that may or may not be processed depending on whether there are any components that can make use of the advice.

The advice list is inherited through the class structure. Advice can also be inhibited for a class and its descendants by surrounding the advice item with a (NOT ..). Note that advice items are only tested for equality by EQL.

See DEEDS:EVENT-CLASS
See ADVICE
See DIRECT-ADVICE

Package

maiden

Source

event.lisp (file)

Direct superclasses

event-class (class)

Direct methods
  • finalize-inheritance (method)
  • direct-advice (method)
  • direct-advice (method)
  • advice (method)
  • advice (method)
Direct slots
Slot: effective-advice
Readers

advice (generic function)

Writers

(setf advice) (generic function)

Slot: direct-advice
Initargs

:advice

Readers

direct-advice (generic function)

Writers

(setf direct-advice) (generic function)

Direct Default Initargs
InitargValue
:direct-advicenil

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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   M  
Index Entry  Section

F
File, Lisp, maiden.asd: The maiden<dot>asd file
File, Lisp, maiden/agent.lisp: The maiden/agent<dot>lisp file
File, Lisp, maiden/client.lisp: The maiden/client<dot>lisp file
File, Lisp, maiden/conditions.lisp: The maiden/conditions<dot>lisp file
File, Lisp, maiden/consumer.lisp: The maiden/consumer<dot>lisp file
File, Lisp, maiden/core.lisp: The maiden/core<dot>lisp file
File, Lisp, maiden/documentation.lisp: The maiden/documentation<dot>lisp file
File, Lisp, maiden/entity.lisp: The maiden/entity<dot>lisp file
File, Lisp, maiden/event.lisp: The maiden/event<dot>lisp file
File, Lisp, maiden/package.lisp: The maiden/package<dot>lisp file
File, Lisp, maiden/standard-events.lisp: The maiden/standard-events<dot>lisp file
File, Lisp, maiden/toolkit.lisp: The maiden/toolkit<dot>lisp file

L
Lisp File, maiden.asd: The maiden<dot>asd file
Lisp File, maiden/agent.lisp: The maiden/agent<dot>lisp file
Lisp File, maiden/client.lisp: The maiden/client<dot>lisp file
Lisp File, maiden/conditions.lisp: The maiden/conditions<dot>lisp file
Lisp File, maiden/consumer.lisp: The maiden/consumer<dot>lisp file
Lisp File, maiden/core.lisp: The maiden/core<dot>lisp file
Lisp File, maiden/documentation.lisp: The maiden/documentation<dot>lisp file
Lisp File, maiden/entity.lisp: The maiden/entity<dot>lisp file
Lisp File, maiden/event.lisp: The maiden/event<dot>lisp file
Lisp File, maiden/package.lisp: The maiden/package<dot>lisp file
Lisp File, maiden/standard-events.lisp: The maiden/standard-events<dot>lisp file
Lisp File, maiden/toolkit.lisp: The maiden/toolkit<dot>lisp file

M
maiden.asd: The maiden<dot>asd file
maiden/agent.lisp: The maiden/agent<dot>lisp file
maiden/client.lisp: The maiden/client<dot>lisp file
maiden/conditions.lisp: The maiden/conditions<dot>lisp file
maiden/consumer.lisp: The maiden/consumer<dot>lisp file
maiden/core.lisp: The maiden/core<dot>lisp file
maiden/documentation.lisp: The maiden/documentation<dot>lisp file
maiden/entity.lisp: The maiden/entity<dot>lisp file
maiden/event.lisp: The maiden/event<dot>lisp file
maiden/package.lisp: The maiden/package<dot>lisp file
maiden/standard-events.lisp: The maiden/standard-events<dot>lisp file
maiden/toolkit.lisp: The maiden/toolkit<dot>lisp file

Jump to:   F   L   M  

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

A.2 Functions

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

(
(setf add-to-consumer): Exported generic functions
(setf add-to-consumer): Exported generic functions
(setf advice): Exported generic functions
(setf advice): Exported generic functions
(setf block-loop): Exported generic functions
(setf block-loop): Exported generic functions
(setf consumers): Exported generic functions
(setf consumers): Exported generic functions
(setf core-handlers): Exported generic functions
(setf core-handlers): Exported generic functions
(setf cores): Exported generic functions
(setf cores): Exported generic functions
(setf data): Exported generic functions
(setf data): Exported generic functions
(setf data-value): Exported generic functions
(setf data-value): Exported generic functions
(setf direct-advice): Internal generic functions
(setf direct-advice): Internal generic functions
(setf direct-handlers): Exported generic functions
(setf direct-handlers): Exported generic functions
(setf direct-handlers): Exported generic functions
(setf effective-handlers): Exported generic functions
(setf effective-handlers): Exported generic functions
(setf effective-handlers): Exported generic functions
(setf id): Exported generic functions
(setf id): Exported generic functions
(setf instances): Exported generic functions
(setf instances): Exported generic functions
(setf lock): Exported generic functions
(setf lock): Exported generic functions
(setf options): Exported generic functions
(setf options): Exported generic functions
(setf primary-loop): Exported generic functions
(setf primary-loop): Exported generic functions
(setf target-class): Exported generic functions
(setf target-class): Exported generic functions

A
add-consumer: Exported generic functions
add-consumer: Exported generic functions
add-consumer: Exported generic functions
add-consumer: Exported generic functions
add-consumer: Exported generic functions
add-consumer: Exported generic functions
add-consumer: Exported generic functions
add-to-consumer: Exported generic functions
add-to-consumer: Exported generic functions
add-to-core: Exported functions
advice: Exported generic functions
advice: Exported generic functions
advice: Exported generic functions
agent: Exported generic functions
agent: Exported generic functions
args->initargs: Internal functions

B
block-loop: Exported generic functions
block-loop: Exported generic functions
broadcast: Exported functions

C
cascade-handler-changes: Internal functions
client: Exported generic functions
client: Exported generic functions
client: Exported generic functions
consumer: Exported generic functions
consumer: Exported generic functions
consumer: Exported generic functions
consumers: Exported generic functions
consumers: Exported generic functions
core: Exported generic functions
core: Exported generic functions
core: Exported generic functions
core-handlers: Exported generic functions
core-handlers: Exported generic functions
cores: Exported generic functions
cores: Exported generic functions

D
data: Exported generic functions
data: Exported generic functions
data-value: Exported generic functions
data-value: Exported generic functions
define-consumer: Exported macros
define-event: Exported macros
define-function-handler: Exported macros
define-handler: Exported macros
define-instruction: Exported macros
define-query: Exported macros
direct-advice: Internal generic functions
direct-advice: Internal generic functions
direct-handlers: Exported generic functions
direct-handlers: Exported generic functions
do-issue: Exported macros

E
effective-handlers: Exported generic functions
effective-handlers: Exported generic functions
enlist: Exported functions
existing-agent: Exported generic functions
existing-agent: Exported generic functions
existing-consumer: Exported generic functions
existing-consumer: Exported generic functions

F
find-consumer-in-package: Exported functions
find-entity: Internal generic functions
find-entity: Internal generic functions
find-entity: Internal generic functions
find-entity: Internal generic functions
find-entity: Internal generic functions
format-absolute-time: Exported functions
format-relative-time: Exported functions
format-time: Exported functions
Function, add-to-core: Exported functions
Function, args->initargs: Internal functions
Function, broadcast: Exported functions
Function, cascade-handler-changes: Internal functions
Function, enlist: Exported functions
Function, find-consumer-in-package: Exported functions
Function, format-absolute-time: Exported functions
Function, format-relative-time: Exported functions
Function, format-time: Exported functions
Function, get-unix-time: Exported functions
Function, kw: Exported functions
Function, make-core: Exported functions
Function, make-updated-list: Internal functions
Function, maybe-invoke-debugger: Exported functions
Function, remove-function-handler: Exported functions
Function, remove-handler: Exported functions
Function, remove-instruction: Exported functions
Function, remove-query: Exported functions
Function, slot-args->args: Internal functions
Function, slot-args->slots: Internal functions
Function, starts-with: Exported functions
Function, swank-connected-p: Internal functions
Function, universal-to-unix: Exported functions
Function, unix-to-universal: Exported functions
Function, unlist: Exported functions
Function, update-handler: Internal functions
Function, update-root-for-image: Internal functions
Function, xnor: Exported functions
Function, xor: Exported functions

G
Generic Function, (setf add-to-consumer): Exported generic functions
Generic Function, (setf advice): Exported generic functions
Generic Function, (setf block-loop): Exported generic functions
Generic Function, (setf consumers): Exported generic functions
Generic Function, (setf core-handlers): Exported generic functions
Generic Function, (setf cores): Exported generic functions
Generic Function, (setf data): Exported generic functions
Generic Function, (setf data-value): Exported generic functions
Generic Function, (setf direct-advice): Internal generic functions
Generic Function, (setf direct-handlers): Exported generic functions
Generic Function, (setf effective-handlers): Exported generic functions
Generic Function, (setf id): Exported generic functions
Generic Function, (setf instances): Exported generic functions
Generic Function, (setf lock): Exported generic functions
Generic Function, (setf options): Exported generic functions
Generic Function, (setf primary-loop): Exported generic functions
Generic Function, (setf target-class): Exported generic functions
Generic Function, add-consumer: Exported generic functions
Generic Function, add-to-consumer: Exported generic functions
Generic Function, advice: Exported generic functions
Generic Function, agent: Exported generic functions
Generic Function, block-loop: Exported generic functions
Generic Function, client: Exported generic functions
Generic Function, consumer: Exported generic functions
Generic Function, consumers: Exported generic functions
Generic Function, core: Exported generic functions
Generic Function, core-handlers: Exported generic functions
Generic Function, cores: Exported generic functions
Generic Function, data: Exported generic functions
Generic Function, data-value: Exported generic functions
Generic Function, direct-advice: Internal generic functions
Generic Function, direct-handlers: Exported generic functions
Generic Function, effective-handlers: Exported generic functions
Generic Function, existing-agent: Exported generic functions
Generic Function, existing-consumer: Exported generic functions
Generic Function, find-entity: Internal generic functions
Generic Function, id: Exported generic functions
Generic Function, instances: Exported generic functions
Generic Function, instantiate-handler: Exported generic functions
Generic Function, lock: Exported generic functions
Generic Function, matches: Exported generic functions
Generic Function, new-consumer: Exported generic functions
Generic Function, options: Exported generic functions
Generic Function, primary-loop: Exported generic functions
Generic Function, reinitialize-handlers: Internal generic functions
Generic Function, remove-consumer: Exported generic functions
Generic Function, respond: Exported generic functions
Generic Function, target-class: Exported generic functions
get-unix-time: Exported functions

I
id: Exported generic functions
id: Exported generic functions
instances: Exported generic functions
instances: Exported generic functions
instantiate-handler: Exported generic functions
instantiate-handler: Exported generic functions

K
kw: Exported functions

L
lock: Exported generic functions
lock: Exported generic functions

M
Macro, define-consumer: Exported macros
Macro, define-event: Exported macros
Macro, define-function-handler: Exported macros
Macro, define-handler: Exported macros
Macro, define-instruction: Exported macros
Macro, define-query: Exported macros
Macro, do-issue: Exported macros
Macro, named-lambda: Exported macros
Macro, update-list: Exported macros
Macro, with-awaiting: Exported macros
Macro, with-default-encoding: Exported macros
Macro, with-retry-restart: Exported macros
make-core: Exported functions
make-updated-list: Internal functions
matches: Exported generic functions
matches: Exported generic functions
matches: Exported generic functions
matches: Exported generic functions
matches: Exported generic functions
matches: Exported generic functions
matches: Exported generic functions
matches: Exported generic functions
matches: Exported generic functions
matches: Exported generic functions
matches: Exported generic functions
matches: Exported generic functions
matches: Exported generic functions
matches: Exported generic functions
matches: Exported generic functions
matches: Exported generic functions
maybe-invoke-debugger: Exported functions
Method, (setf add-to-consumer): Exported generic functions
Method, (setf advice): Exported generic functions
Method, (setf block-loop): Exported generic functions
Method, (setf consumers): Exported generic functions
Method, (setf core-handlers): Exported generic functions
Method, (setf cores): Exported generic functions
Method, (setf data): Exported generic functions
Method, (setf data-value): Exported generic functions
Method, (setf direct-advice): Internal generic functions
Method, (setf direct-handlers): Exported generic functions
Method, (setf direct-handlers): Exported generic functions
Method, (setf effective-handlers): Exported generic functions
Method, (setf effective-handlers): Exported generic functions
Method, (setf id): Exported generic functions
Method, (setf instances): Exported generic functions
Method, (setf lock): Exported generic functions
Method, (setf options): Exported generic functions
Method, (setf primary-loop): Exported generic functions
Method, (setf target-class): Exported generic functions
Method, add-consumer: Exported generic functions
Method, add-consumer: Exported generic functions
Method, add-consumer: Exported generic functions
Method, add-consumer: Exported generic functions
Method, add-consumer: Exported generic functions
Method, add-consumer: Exported generic functions
Method, add-to-consumer: Exported generic functions
Method, advice: Exported generic functions
Method, advice: Exported generic functions
Method, agent: Exported generic functions
Method, block-loop: Exported generic functions
Method, client: Exported generic functions
Method, client: Exported generic functions
Method, consumer: Exported generic functions
Method, consumer: Exported generic functions
Method, consumers: Exported generic functions
Method, core: Exported generic functions
Method, core: Exported generic functions
Method, core-handlers: Exported generic functions
Method, cores: Exported generic functions
Method, data: Exported generic functions
Method, data-value: Exported generic functions
Method, direct-advice: Internal generic functions
Method, direct-handlers: Exported generic functions
Method, effective-handlers: Exported generic functions
Method, existing-agent: Exported generic functions
Method, existing-consumer: Exported generic functions
Method, find-entity: Internal generic functions
Method, find-entity: Internal generic functions
Method, find-entity: Internal generic functions
Method, find-entity: Internal generic functions
Method, id: Exported generic functions
Method, instances: Exported generic functions
Method, instantiate-handler: Exported generic functions
Method, lock: Exported generic functions
Method, matches: Exported generic functions
Method, matches: Exported generic functions
Method, matches: Exported generic functions
Method, matches: Exported generic functions
Method, matches: Exported generic functions
Method, matches: Exported generic functions
Method, matches: Exported generic functions
Method, matches: Exported generic functions
Method, matches: Exported generic functions
Method, matches: Exported generic functions
Method, matches: Exported generic functions
Method, matches: Exported generic functions
Method, matches: Exported generic functions
Method, matches: Exported generic functions
Method, matches: Exported generic functions
Method, new-consumer: Exported generic functions
Method, options: Exported generic functions
Method, primary-loop: Exported generic functions
Method, reinitialize-handlers: Internal generic functions
Method, reinitialize-handlers: Internal generic functions
Method, remove-consumer: Exported generic functions
Method, remove-consumer: Exported generic functions
Method, remove-consumer: Exported generic functions
Method, remove-consumer: Exported generic functions
Method, remove-consumer: Exported generic functions
Method, remove-consumer: Exported generic functions
Method, respond: Exported generic functions
Method, respond: Exported generic functions
Method, respond: Exported generic functions
Method, target-class: Exported generic functions

N
named-lambda: Exported macros
new-consumer: Exported generic functions
new-consumer: Exported generic functions

O
options: Exported generic functions
options: Exported generic functions

P
primary-loop: Exported generic functions
primary-loop: Exported generic functions

R
reinitialize-handlers: Internal generic functions
reinitialize-handlers: Internal generic functions
reinitialize-handlers: Internal generic functions
remove-consumer: Exported generic functions
remove-consumer: Exported generic functions
remove-consumer: Exported generic functions
remove-consumer: Exported generic functions
remove-consumer: Exported generic functions
remove-consumer: Exported generic functions
remove-consumer: Exported generic functions
remove-function-handler: Exported functions
remove-handler: Exported functions
remove-instruction: Exported functions
remove-query: Exported functions
respond: Exported generic functions
respond: Exported generic functions
respond: Exported generic functions
respond: Exported generic functions

S
slot-args->args: Internal functions
slot-args->slots: Internal functions
starts-with: Exported functions
swank-connected-p: Internal functions

T
target-class: Exported generic functions
target-class: Exported generic functions

U
universal-to-unix: Exported functions
unix-to-universal: Exported functions
unlist: Exported functions
update-handler: Internal functions
update-list: Exported macros
update-root-for-image: Internal functions

W
with-awaiting: Exported macros
with-default-encoding: Exported macros
with-retry-restart: Exported macros

X
xnor: Exported functions
xor: Exported functions

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

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

A.3 Variables

Jump to:   *  
A   B   C   D   E   I   N   O   P   S   T  
Index Entry  Section

*
*debugger*: Exported special variables
*root*: Exported special variables
*unix-epoch-difference*: Internal special variables

A
add-to-consumer: Exported classes
agent: Exported conditions

B
block-loop: Exported classes

C
client: Exported conditions
client: Exported classes
consumer: Exported classes
consumer: Exported classes
consumers: Exported classes
core: Exported conditions
core-handlers: Exported classes
cores: Exported classes

D
data: Exported classes
direct-advice: Internal classes
direct-handlers: Exported classes

E
effective-advice: Internal classes
effective-handlers: Exported classes
event-loop-lock: Exported classes
existing-agent: Exported conditions
existing-consumer: Exported conditions

I
id: Exported classes
instances: Exported classes

N
name: Exported classes
name: Exported classes
new-consumer: Exported conditions

O
options: Exported classes

P
primary-loop: Exported classes

S
Slot, add-to-consumer: Exported classes
Slot, agent: Exported conditions
Slot, block-loop: Exported classes
Slot, client: Exported conditions
Slot, client: Exported classes
Slot, consumer: Exported classes
Slot, consumer: Exported classes
Slot, consumers: Exported classes
Slot, core: Exported conditions
Slot, core-handlers: Exported classes
Slot, cores: Exported classes
Slot, data: Exported classes
Slot, direct-advice: Internal classes
Slot, direct-handlers: Exported classes
Slot, effective-advice: Internal classes
Slot, effective-handlers: Exported classes
Slot, event-loop-lock: Exported classes
Slot, existing-agent: Exported conditions
Slot, existing-consumer: Exported conditions
Slot, id: Exported classes
Slot, instances: Exported classes
Slot, name: Exported classes
Slot, name: Exported classes
Slot, new-consumer: Exported conditions
Slot, options: Exported classes
Slot, primary-loop: Exported classes
Slot, target-class: Exported classes
Special Variable, *debugger*: Exported special variables
Special Variable, *root*: Exported special variables
Special Variable, *unix-epoch-difference*: Internal special variables

T
target-class: Exported classes

Jump to:   *  
A   B   C   D   E   I   N   O   P   S   T  

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

A.4 Data types

Jump to:   A   B   C   D   E   I   M   N   P   Q   S  
Index Entry  Section

A
abstract-handler: Exported classes
active-event: Exported classes
agent: Exported classes
agent-already-exists-error: Exported conditions
agent-condition: Exported conditions

B
block-loop: Exported classes

C
Class, abstract-handler: Exported classes
Class, active-event: Exported classes
Class, agent: Exported classes
Class, block-loop: Exported classes
Class, client: Exported classes
Class, client-event: Exported classes
Class, consumer: Exported classes
Class, consumer-added: Exported classes
Class, consumer-class: Exported classes
Class, consumer-removed: Exported classes
Class, core: Exported classes
Class, core-event: Exported classes
Class, data-entity: Exported classes
Class, entity: Exported classes
Class, event: Exported classes
Class, event-class: Internal classes
Class, instruction-event: Exported classes
Class, named-entity: Exported classes
Class, passive-event: Exported classes
Class, primary-loop: Exported classes
Class, query-event: Exported classes
client: Exported classes
client-condition: Exported conditions
client-event: Exported classes
Condition, agent-already-exists-error: Exported conditions
Condition, agent-condition: Exported conditions
Condition, client-condition: Exported conditions
Condition, consumer-name-duplicated-warning: Exported conditions
Condition, core-condition: Exported conditions
Condition, maiden-condition: Exported conditions
consumer: Exported classes
consumer-added: Exported classes
consumer-class: Exported classes
consumer-name-duplicated-warning: Exported conditions
consumer-removed: Exported classes
core: Exported classes
core-condition: Exported conditions
core-event: Exported classes

D
data-entity: Exported classes

E
entity: Exported classes
event: Exported classes
event-class: Internal classes

I
instruction-event: Exported classes

M
maiden: The maiden system
maiden: The maiden package
maiden-condition: Exported conditions
maiden-user: The maiden-user package

N
named-entity: Exported classes

P
Package, maiden: The maiden package
Package, maiden-user: The maiden-user package
passive-event: Exported classes
primary-loop: Exported classes

Q
query-event: Exported classes

S
System, maiden: The maiden system

Jump to:   A   B   C   D   E   I   M   N   P   Q   S