The calispel Reference Manual

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

The calispel Reference Manual

This is the calispel Reference Manual, version 0.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Tue Nov 15 04:21:48 2022 GMT+0.

Table of Contents


1 Introduction

Calispel is a Common Lisp library for thread-safe message-passing
channels, in the style of the occam programming language.

Written by J.P. Larocque .  Based on
work by Roger Peppe and Russ Cox; see COPYRIGHT.txt for full
attribution.

See doc/doc.html or doc/doc.txt for usage examples and a reference.


2 Systems

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


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

2.1 calispel

Thread-safe message-passing channels, in the style of the occam programming language.

Maintainer

J.P. Larocque

Author

J.P. Larocque, et al. (see COPYRIGHT.txt)

License

ISC-style and other permissive (see COPYRIGHT.txt)

Version

0.1

Dependencies
  • jpl-queues (system).
  • bordeaux-threads (system).
  • jpl-util (system)., at least version "0.2"
Source

calispel.asd.

Child Components

3 Files

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


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

3.1 Lisp


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

3.1.1 calispel/calispel.asd

Source

calispel.asd.

Parent Component

calispel (system).

ASDF Systems

calispel.


3.1.2 calispel/core.lisp

Dependencies
Source

calispel.asd.

Parent Component

calispel (system).

Public Interface
Internals

3.1.3 calispel/basic.lisp

Dependencies
Source

calispel.asd.

Parent Component

calispel (system).

Public Interface
  • ! (function).
  • ? (function).

3.1.4 calispel/alt.lisp

Dependencies
Source

calispel.asd.

Parent Component

calispel (system).

Public Interface
Internals

3.1.5 calispel/null-queue.lisp

Dependency

package.lisp (file).

Source

calispel.asd.

Parent Component

calispel (system).

Public Interface

3.1.6 calispel/package.lisp

Source

calispel.asd.

Parent Component

calispel (system).

Packages

calispel.


4 Packages

Packages are listed by definition order.


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

4.1 calispel

Source

package.lisp.

Use List

common-lisp.

Public Interface
Internals

5 Definitions

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


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

5.1 Public Interface


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

5.1.1 Special variables

Special Variable: +null-queue+
Package

calispel.

Source

null-queue.lisp.


5.1.2 Macros

Macro: fair-alt (&body clauses)

Performs one of the given channel operations, choosing fairly from the set of operations that first becomes available, then evaluates each of the forms associated with the selected operation. If no operation can immediately be made, waits until an operation is available (optionally up to a given timeout). The result is the result of the final evaluated form (or no values if no clause was executed).

clauses ::= operation-clause* [otherwise-clause] operation-clause ::= (operation form*)
otherwise-clause ::= ({otherwise | (otherwise [:timeout timeout])} form*) operation ::= (? channel [lambda-list [condition]]) ; receive | (! channel value [condition]) ; send

channel: Evaluated to produce a CHANNEL to send to or receive from. The channel forms associated with operations that do not pass the condition are not evaluated.

lambda-list: Either a symbol naming a variable to be bound to the value received from the channel, or a destructuring lambda list naming a set of variables to be bound to the destructured value received from the channel. The bindings are visible to the associated forms. If the value cannot be destructured according to the lambda list, an error is signalled. Note that multiple receive clauses for the same channel with different destructuring lambda-lists *cannot* be used for pattern matching.

value: An expression whose primary value is used as the message to send to the channel. All value expressions are evaluated before selecting an operation, except for those associated with operations that do not pass the condition.

condition: Evaluated to produce a generalized boolean indicating whether the associated operation-clause should receive further consideration. When condition is not given or its resulting value is true, the associated operation is kept for consideration. When the resulting value is false, the operation is removed from
consideration (as if its associated channel never becomes ready for sending/receiving).

form: Evaluated in sequence when the associated clause is executed. The values of the evaluation of the last form of the effective clause become the result of FAIR-ALT.

timeout: Evaluated to produce the duration, as a non-negative REAL number of seconds, to wait for an effective operation to become available before resorting to the otherwise-clause. The result may also be NIL to specify no time out. When an otherwise-clause exists, the default time out is 0, meaning that if none of the channels in the operation-clauses are immediately available, the otherwise-clause forms are executed immediately. When there is no otherwise-clause, the default time out is NIL.

It is useful to specify a timeout expression that conditionally evaluates to NIL, in order to disable the time out and inhibit the execution of the otherwise-clause (provided that there are channel operations to wait for that haven’t been excluded by a false condition).

If there are no effective operations (because all the conditions evaluated to false, or because no operations were specified), then the otherwise-clause (if any) is executed immediately (even if the specified time out is NIL).

Stylistically and for future compatibility, avoid side-effects in channel, value, condition, and timeout expressions.

Package

calispel.

Source

alt.lisp.

Macro: pri-alt (&body clauses)

Performs one of the given channel operations, choosing the first listed operation that becomes available, then evaluates each of the forms associated with the selected operation. If no operation can immediately be made, waits until an operation is available (optionally up to a given timeout). The result is the result of the final evaluated form (or no values if no clause was executed).

The syntax and semantics (other than clause priority) are the same as with FAIR-ALT. PRI-ALT is (currently) more efficient than FAIR-ALT.

Package

calispel.

Source

alt.lisp.


5.1.3 Ordinary functions

Function: ! (channel value &optional timeout)

Send VALUE on CHANNEL, waiting up to TIMEOUT seconds (a non-negative REAL number; or indefinitely when NIL). Returns a boolean indicating whether the timeout expired before the value could be sent.

Package

calispel.

Source

basic.lisp.

Function: ? (channel &optional timeout)

Receive a value from CHANNEL, waiting up to TIMEOUT seconds (a non-negative REAL number; or indefinitely when NIL). Returns the value (or NIL upon timeout) and a boolean indicating whether the timeout expired before a value could be received.

Package

calispel.

Source

basic.lisp.

Function: operation-alternate (timeout priority ops)

Given a list of at least one OPERATION, executes the first one that becomes available within TIMEOUT seconds and returns that OPERATION. If TIMEOUT seconds have elapsed without any of the OPERATIONs becoming available, returns NIL. If TIMEOUT is NIL, waits indefinitely.

If one or more of the OPERATIONs can be executed immediately, which one is chosen depends on the value of PRIORITY. When PRIORITY
is :FIRST, the first OPERATION listed in OPS that can be executed is chosen. When PRIORITY is :FAIR, one of the OPERATIONs that can be executed immediately is chosen at random.

Package

calispel.

Source

core.lisp.


5.1.4 Generic functions

Generic Reader: channel (object)
Package

calispel.

Methods
Reader Method: channel ((operation operation))

The CHANNEL this OPERATION is interested in operating on.

Source

core.lisp.

Target Slot

channel.

Generic Reader: direction (object)
Package

calispel.

Methods
Reader Method: direction ((operation operation))

Which DIRECTION this OPERATION is trying
to move data in.

When SEND, the OPERATION is interested in sending the value specified by :VALUE to CHANNEL.

When RECEIVE, the OPERATION is interested in receiving a value from CHANNEL.

Source

core.lisp.

Target Slot

direction.

Generic Reader: value (object)
Generic Writer: (setf value) (object)
Package

calispel.

Methods
Reader Method: value ((operation operation))
Writer Method: (setf value) ((operation operation))

The value associated with this OPERATION.

When sending, this is the value to send.

When receiving, this is the received value if the OPERATION has executed, or undefined if it has not.

Source

core.lisp.

Target Slot

value.


5.1.5 Standalone methods

Method: capacity ((queue null-queue))
Package

jpl-queues.

Source

null-queue.lisp.

Method: dequeue ((queue null-queue))
Package

jpl-queues.

Source

null-queue.lisp.

Method: dequeue-object-if (predicate (queue null-queue) &key &allow-other-keys)
Package

jpl-queues.

Source

null-queue.lisp.

Method: empty? ((queue null-queue))
Package

jpl-queues.

Source

null-queue.lisp.

Method: enqueue (object (queue null-queue))
Package

jpl-queues.

Source

null-queue.lisp.

Method: full? ((queue null-queue))
Package

jpl-queues.

Source

null-queue.lisp.

Method: initialize-instance :after ((channel channel) &key &allow-other-keys)
Source

core.lisp.

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

core.lisp.

Method: size ((queue null-queue))
Package

jpl-queues.

Source

null-queue.lisp.


5.1.6 Classes

Class: channel

A communication channel.

Package

calispel.

Source

core.lisp.

Direct methods
Direct slots
Slot: buffer

The QUEUE used to buffer pending objects.

The QUEUE must not be holding any objects, and the QUEUE must not be used again unless the CHANNEL owning it is never used
again. (Exception: QUEUEs that strictly have no state, such as instances of NULL-QUEUE, may be shared among CHANNELs.)

Type

jpl-queues:queue

Initform

calispel:+null-queue+

Initargs

:buffer

Readers

buffer.

Writers

This slot is read-only.

Slot: send-operation-queue

A queue of all the
OPERATIONs waiting to send to this CHANNEL. An OPERATION may be waiting to send only when BUFFER is full.

Type

jpl-queues:queue

Initform

(make-instance (quote jpl-queues:unbounded-random-queue))

Readers

send-operation-queue.

Writers

This slot is read-only.

Slot: receive-operation-queue

A queue of all the
OPERATIONs waiting to receive from this channel. An OPERATION may be waiting to receive only when BUFFER is empty.

Type

jpl-queues:queue

Initform

(make-instance (quote jpl-queues:unbounded-random-queue))

Readers

receive-operation-queue.

Writers

This slot is read-only.

Class: null-queue

The null queue. Used for unbuffered CHANNELs.

Think of it as the NULL class, but for queues.

Package

calispel.

Source

null-queue.lisp.

Direct superclasses

queue.

Direct methods
Class: operation

A potential operation (receive or send) to perform
on a channel. An OPERATION instance represents an interest to perform the operation; it does not represent an operation that definitely will be or has been carried out.

Package

calispel.

Source

core.lisp.

Direct subclasses

alt-operation.

Direct methods
Direct slots
Slot: direction

Which DIRECTION this OPERATION is trying
to move data in.

When SEND, the OPERATION is interested in sending the value specified by :VALUE to CHANNEL.

When RECEIVE, the OPERATION is interested in receiving a value from CHANNEL.

Type

calispel:direction

Initform

(error "must supply :direction.")

Initargs

:direction

Readers

direction.

Writers

This slot is read-only.

Slot: channel

The CHANNEL this OPERATION is interested in operating on.

Type

calispel:channel

Initform

(error "must supply :channel.")

Initargs

:channel

Readers

channel.

Writers

This slot is read-only.

Slot: value

The value associated with this OPERATION.

When sending, this is the value to send.

When receiving, this is the received value if the OPERATION has executed, or undefined if it has not.

Initargs

:value

Readers

value.

Writers

(setf value).

Slot: alternation

The ALTERNATION (if any) that this OPERATION is a member of.

Type

calispel::alternation

Readers

alternation.

Writers

(setf alternation).


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

5.1.7 Types

Type: direction ()
Package

calispel.

Source

core.lisp.


5.2 Internals


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

5.2.1 Special variables

Special Variable: *lock*

A lock protecting the global channel state. The lock must be held whenever any data is being accessed (unless it can be proven that no other thread can access that data). Specifically, that means CHANNELs, OPERATIONs, and ALTERNATIONs that other threads can potentially get access to.

Package

calispel.

Source

core.lisp.


5.2.2 Ordinary functions

Function: alt-body-code (op-conditions op-forms priority otherwise-p timeout-form otherwise-forms)
Package

calispel.

Source

alt.lisp.

Function: alt-code (clauses priority)
Package

calispel.

Source

alt.lisp.

Function: alternation-wait (timeout alternation)

Given an ALTERNATION, waits up to TIMEOUT seconds for another thread to execute one of its OPERATIONs (or indefinitely when TIMEOUT is NIL). The SELECTED slot of ALTERNATION must initially be NIL.

Upon return, if another thread executed one of the OPERATIONs of ALTERNATION, that OPERATION will appear in the SELECTED slot of ALTERNATION. Otherwise (if timed-out), that slot will be NIL.

Must be called with *LOCK* held.

Package

calispel.

Source

core.lisp.

Function: dequeue-channel-for-operation (receiving-op)

Dequeues the oldest object from the the BUFFER of the CHANNEL that RECEIVING-OP is interested in receiving from, storing it in RECEIVING-OP.

RECEIVING-OP must be interested in receiving. The CHANNEL must have at least one object in its BUFFER.

Must be called with *LOCK* held.

Package

calispel.

Source

core.lisp.

Function: dequeue-operation-with-channel (op)

Given an OPERATION that will no longer be waiting, dequeues it from the vector of OPERATIONs waiting on CHANNEL (where CHANNEL is the CHANNEL that the OPERATION was interested in).

Must be called with *LOCK* held.

Package

calispel.

Source

core.lisp.

Function: enqueue-channel-for-operation (sending-op)

Enqueues the object stored in SENDING-OP to the BUFFER of the CHANNEL that SENDING-OP is interested in sending to.

SENDING-OP must be interested in sending. The CHANNEL must have room in its BUFFER for at least one object.

Must be called with *LOCK* held.

Package

calispel.

Source

core.lisp.

Function: enqueue-operation-with-channel (op)

Given an OPERATION that is about to wait, enqueues it with the vector of OPERATIONs waiting on CHANNEL (where CHANNEL is the CHANNEL that the OPERATION is interested in).

Must be called with *LOCK* held.

Package

calispel.

Source

core.lisp.

Function: enqueue/dequeue-channel-from-op-to-op (sending-op receiving-op)

Given SENDING-OP (an OPERATION interested in sending to a channel), and RECEIVING-OP (an OPERATION interested in receiving from the same channel), enqueues SENDING-OP’s object and dequeues an object for RECEIVING-OP, at the same time.

Must be called with *LOCK* held.

Package

calispel.

Source

core.lisp.

Function: execute-operation (op)

Executes the given OPERATION. It must be ready (per OPERATION-READY?).

Must be called with *LOCK* held.

Package

calispel.

Source

core.lisp.

Function: invoke-action (op)

Invokes the action associated with the given ALT-OPERATION.

Package

calispel.

Source

alt.lisp.

Function: op-!-clause-condition (clause-operands)
Package

calispel.

Source

alt.lisp.

Function: op-!-clause-form (clause-operands body)
Package

calispel.

Source

alt.lisp.

Function: op-?-clause-condition (clause-operands)
Package

calispel.

Source

alt.lisp.

Function: op-?-clause-form (clause-operands body)
Package

calispel.

Source

alt.lisp.

Function: op-clause-condition (clause)
Package

calispel.

Source

alt.lisp.

Function: op-clause-form (clause)
Package

calispel.

Source

alt.lisp.

Function: operation-queue (channel direction)

Returns the queue of all the OPERATIONs waiting to move data in DIRECTION on CHANNEL. When DIRECTION is SEND, the returned OPERATIONs are those waiting until the BUFFER of CHANNEL is no longer full. When RECEIVE, the returned OPERATIONs are those waiting until the BUFFER is no longer empty.

Package

calispel.

Source

core.lisp.

Function: operation-ready? (op)

Returns a boolean value indicating whether the given OPERATION can be executed.

Must be called with *LOCK* held.

Package

calispel.

Source

core.lisp.

Function: operation-transfer (sending-op receiving-op)

Transfers one object from SENDING-OP to RECEIVING-OP.

SENDING-OP must be interested in sending, and RECEIVING-OP in receiving. They must be interested in the same channel, and the channel’s BUFFER must be empty.

Must be called with *LOCK* held.

Package

calispel.

Source

core.lisp.

Function: opposite-direction (direction)
Package

calispel.

Source

core.lisp.

Function: otherwise-clause? (clause)
Package

calispel.

Source

alt.lisp.

Function: parse-otherwise-clause (clause)
Package

calispel.

Source

alt.lisp.


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

5.2.3 Generic functions

Generic Reader: action (object)
Package

calispel.

Methods
Reader Method: action ((alt-operation alt-operation))

A function to be called when this OPERATION
succeeds.

When DIRECTION is SEND, the function is called with no arguments.

When DIRECTION is RECEIVE, the function is called with the received value.

The result of this function is the result of the ALT macro form.

Source

alt.lisp.

Target Slot

action.

Generic Reader: alternation (object)
Generic Writer: (setf alternation) (object)
Package

calispel.

Methods
Reader Method: alternation ((operation operation))
Writer Method: (setf alternation) ((operation operation))

The ALTERNATION (if any) that this OPERATION is a member of.

Source

core.lisp.

Target Slot

alternation.

Generic Reader: buffer (object)
Package

calispel.

Methods
Reader Method: buffer ((channel channel))

The QUEUE used to buffer pending objects.

The QUEUE must not be holding any objects, and the QUEUE must not be used again unless the CHANNEL owning it is never used
again. (Exception: QUEUEs that strictly have no state, such as instances of NULL-QUEUE, may be shared among CHANNELs.)

Source

core.lisp.

Target Slot

buffer.

Generic Reader: operations (object)
Package

calispel.

Methods
Reader Method: operations ((alternation alternation))

The set of OPERATIONs waiting to occur (as a list).

Source

core.lisp.

Target Slot

operations.

Generic Reader: receive-operation-queue (object)
Package

calispel.

Methods
Reader Method: receive-operation-queue ((channel channel))

A queue of all the
OPERATIONs waiting to receive from this channel. An OPERATION may be waiting to receive only when BUFFER is empty.

Source

core.lisp.

Target Slot

receive-operation-queue.

Generic Reader: selected (object)
Generic Writer: (setf selected) (object)
Package

calispel.

Methods
Reader Method: selected ((alternation alternation))
Writer Method: (setf selected) ((alternation alternation))

The OPERATION selected by a thread that
took action, or NIL if no OPERATION has yet been executed by another thread.

The thread that writes to SELECTED is generally a different thread than that which waits on the ALTERNATION.

The OPERATION, when given, must have been executed, and it must appear in the OPERATIONS slot.

Source

core.lisp.

Target Slot

selected.

Generic Reader: selection-cv (object)
Package

calispel.

Methods
Reader Method: selection-cv ((alternation alternation))

A condition variable which is
notified when an OPERATION has been selected and was written to the SELECTED slot.

The thread that waits on SELECTION-CV is generally that which is waiting on the ALTERNATION.

Source

core.lisp.

Target Slot

selection-cv.

Generic Reader: send-operation-queue (object)
Package

calispel.

Methods
Reader Method: send-operation-queue ((channel channel))

A queue of all the
OPERATIONs waiting to send to this CHANNEL. An OPERATION may be waiting to send only when BUFFER is full.

Source

core.lisp.

Target Slot

send-operation-queue.


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

5.2.4 Classes

Class: alt-operation

An OPERATION with bookkeeping for use by the *-ALT macros.

Package

calispel.

Source

alt.lisp.

Direct superclasses

operation.

Direct methods

action.

Direct slots
Slot: action

A function to be called when this OPERATION
succeeds.

When DIRECTION is SEND, the function is called with no arguments.

When DIRECTION is RECEIVE, the function is called with the received value.

The result of this function is the result of the ALT macro form.

Type

function

Initform

(error "must supply :action.")

Initargs

:action

Readers

action.

Writers

This slot is read-only.

Class: alternation

Represents a waiting alternation of several
OPERATIONs. That is, represents the act of waiting for the associated OPERATION that first becomes available.

Package

calispel.

Source

core.lisp.

Direct methods
Direct slots
Slot: operations

The set of OPERATIONs waiting to occur (as a list).

Type

list

Initform

(error "must supply :operations.")

Initargs

:operations

Readers

operations.

Writers

This slot is read-only.

Slot: selected

The OPERATION selected by a thread that
took action, or NIL if no OPERATION has yet been executed by another thread.

The thread that writes to SELECTED is generally a different thread than that which waits on the ALTERNATION.

The OPERATION, when given, must have been executed, and it must appear in the OPERATIONS slot.

Type

(or calispel:operation null)

Readers

selected.

Writers

(setf selected).

Slot: selection-cv

A condition variable which is
notified when an OPERATION has been selected and was written to the SELECTED slot.

The thread that waits on SELECTION-CV is generally that which is waiting on the ALTERNATION.

Initform

(bordeaux-threads:make-condition-variable)

Readers

selection-cv.

Writers

This slot is read-only.


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   !   (   ?  
A   B   C   D   E   F   G   I   M   O   P   R   S   V  
Index Entry  Section

!
!: Public ordinary functions

(
(setf alternation): Private generic functions
(setf alternation): Private generic functions
(setf selected): Private generic functions
(setf selected): Private generic functions
(setf value): Public generic functions
(setf value): Public generic functions

?
?: Public ordinary functions

A
action: Private generic functions
action: Private generic functions
alt-body-code: Private ordinary functions
alt-code: Private ordinary functions
alternation: Private generic functions
alternation: Private generic functions
alternation-wait: Private ordinary functions

B
buffer: Private generic functions
buffer: Private generic functions

C
capacity: Public standalone methods
channel: Public generic functions
channel: Public generic functions

D
dequeue: Public standalone methods
dequeue-channel-for-operation: Private ordinary functions
dequeue-object-if: Public standalone methods
dequeue-operation-with-channel: Private ordinary functions
direction: Public generic functions
direction: Public generic functions

E
empty?: Public standalone methods
enqueue: Public standalone methods
enqueue-channel-for-operation: Private ordinary functions
enqueue-operation-with-channel: Private ordinary functions
enqueue/dequeue-channel-from-op-to-op: Private ordinary functions
execute-operation: Private ordinary functions

F
fair-alt: Public macros
full?: Public standalone methods
Function, !: Public ordinary functions
Function, ?: Public ordinary functions
Function, alt-body-code: Private ordinary functions
Function, alt-code: Private ordinary functions
Function, alternation-wait: Private ordinary functions
Function, dequeue-channel-for-operation: Private ordinary functions
Function, dequeue-operation-with-channel: Private ordinary functions
Function, enqueue-channel-for-operation: Private ordinary functions
Function, enqueue-operation-with-channel: Private ordinary functions
Function, enqueue/dequeue-channel-from-op-to-op: Private ordinary functions
Function, execute-operation: Private ordinary functions
Function, invoke-action: Private ordinary functions
Function, op-!-clause-condition: Private ordinary functions
Function, op-!-clause-form: Private ordinary functions
Function, op-?-clause-condition: Private ordinary functions
Function, op-?-clause-form: Private ordinary functions
Function, op-clause-condition: Private ordinary functions
Function, op-clause-form: Private ordinary functions
Function, operation-alternate: Public ordinary functions
Function, operation-queue: Private ordinary functions
Function, operation-ready?: Private ordinary functions
Function, operation-transfer: Private ordinary functions
Function, opposite-direction: Private ordinary functions
Function, otherwise-clause?: Private ordinary functions
Function, parse-otherwise-clause: Private ordinary functions

G
Generic Function, (setf alternation): Private generic functions
Generic Function, (setf selected): Private generic functions
Generic Function, (setf value): Public generic functions
Generic Function, action: Private generic functions
Generic Function, alternation: Private generic functions
Generic Function, buffer: Private generic functions
Generic Function, channel: Public generic functions
Generic Function, direction: Public generic functions
Generic Function, operations: Private generic functions
Generic Function, receive-operation-queue: Private generic functions
Generic Function, selected: Private generic functions
Generic Function, selection-cv: Private generic functions
Generic Function, send-operation-queue: Private generic functions
Generic Function, value: Public generic functions

I
initialize-instance: Public standalone methods
invoke-action: Private ordinary functions

M
Macro, fair-alt: Public macros
Macro, pri-alt: Public macros
Method, (setf alternation): Private generic functions
Method, (setf selected): Private generic functions
Method, (setf value): Public generic functions
Method, action: Private generic functions
Method, alternation: Private generic functions
Method, buffer: Private generic functions
Method, capacity: Public standalone methods
Method, channel: Public generic functions
Method, dequeue: Public standalone methods
Method, dequeue-object-if: Public standalone methods
Method, direction: Public generic functions
Method, empty?: Public standalone methods
Method, enqueue: Public standalone methods
Method, full?: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, operations: Private generic functions
Method, print-object: Public standalone methods
Method, receive-operation-queue: Private generic functions
Method, selected: Private generic functions
Method, selection-cv: Private generic functions
Method, send-operation-queue: Private generic functions
Method, size: Public standalone methods
Method, value: Public generic functions

O
op-!-clause-condition: Private ordinary functions
op-!-clause-form: Private ordinary functions
op-?-clause-condition: Private ordinary functions
op-?-clause-form: Private ordinary functions
op-clause-condition: Private ordinary functions
op-clause-form: Private ordinary functions
operation-alternate: Public ordinary functions
operation-queue: Private ordinary functions
operation-ready?: Private ordinary functions
operation-transfer: Private ordinary functions
operations: Private generic functions
operations: Private generic functions
opposite-direction: Private ordinary functions
otherwise-clause?: Private ordinary functions

P
parse-otherwise-clause: Private ordinary functions
pri-alt: Public macros
print-object: Public standalone methods

R
receive-operation-queue: Private generic functions
receive-operation-queue: Private generic functions

S
selected: Private generic functions
selected: Private generic functions
selection-cv: Private generic functions
selection-cv: Private generic functions
send-operation-queue: Private generic functions
send-operation-queue: Private generic functions
size: Public standalone methods

V
value: Public generic functions
value: Public generic functions

Jump to:   !   (   ?  
A   B   C   D   E   F   G   I   M   O   P   R   S   V