The cl-gserver Reference Manual

Table of Contents

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

The cl-gserver Reference Manual

This is the cl-gserver Reference Manual, version 0.2.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Tue Apr 28 11:00:14 2020 GMT+0.


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

1 Introduction

Cl-GServer

GServer is an Erlang inspired GenServer. It is meant to encapsulate state, but also to execute async operations.
Encapsulating state also means that it gives a safe facility to update state within a multi-threaded environment without having you to worry about maintaining access to state.

State can be changed and maintained by calling into the server via 'call' or 'cast'.
Where 'call' is synchronous and waits for a result, 'cast' is asynchronous and responds just with t. For each 'call' and 'cast' handlers must be implemented by subclasses.

GServer runs it's own thread that handles the incoming messages and maintains the state. In that regard message handling should be quick. Long operations should be delegated to elsewhere.

In it's functionality regarding state it is also not unsimilar:

But, on GenServer (or Gserver) two more implementations in this libarary are based on it, that is Clojure's Agent and Akkas Actor. At least in a local form. None of this supports remoting, yet.

Usage

GServer

Creating a custom gserver

First :use :cl-gserver.

Let's create a simple stack gserver:

First create a new subclass of gserver:

(defclass stack-server (gserver) ())
Synchronous call

Then implement handle-call method which is used to pop or get values since calling a gserver waits for result. Both handle-call and handle-cast provide three parameters. That is the 'server' instance ('self' if you want), the 'message' that was sent, and the 'current-state' of the gserver:

(defmethod handle-call ((server stack-server) message current-state)
  (log:debug "current-state: " current-state)
  (match message
    (:pop
     (cons
      (car current-state)
      (cdr current-state)))
    (:get
     (cons current-state current-state))))

This implements two message handlers using pattern matching with help of trivia library.
You are free to implement the handlers however you like as long as the return conventions are met. An error is raised if no cons is returned, in which case the server responds with (cons :handler-error "<error-message>") to the call.

The convention of handle-call is to always return a cons where the car value is to be returned and the new state value is cdr.

So :pop in the examnple takes the current car of the backing list which will be returned to the caller and cdr of the current state will become the new state.

Asynchronous cast

Now we also want to push values. This will be done by casting to the server.

(defmethod handle-cast ((server stack-server) message current-state)
  (log:debug "current-state: " current-state)
  (match message
    ((cons :push value)
     (let ((new-state (append current-state (list value))))
       (cons new-state new-state)))))

cast is asynchronous and just responds with t. So we can use it to push values to the stack. We still have to return a cons. However, the car of the cons is kind of irrelevant, because it's not returned to the caller. The cdr is important as it will get the new state.

Disclaimer: this is a completely naive implementaion of a stack just using a cons list. Disclaimer2: since cast is asynchronous the push might not yet has updated the gserver state when you do a pop immediately after. So this is not the best example for a cast.

Make instance of stack-server

Now we can make a new server instance with a predefined stack of one entry: 5:

(defparameter *stack-server* (make-instance 'stack-server :state '(5)))

Let's push new values:

(cast *stack-server* (cons :push 4))
(cast *stack-server* (cons :push 3))
(cast *stack-server* (cons :push 2))

When we check the state, we get:

(call *stack-server* :get)
=> returns '(5 4 3 2)

We can also pop the stack:

(call *stack-server* :pop)
=> returns 5
(call *stack-server* :pop)
=> returns 4
(call *stack-server* :pop)
=> returns 3
(call *stack-server* :pop)
=> returns 2

Performance considerations

As in this simple test 100_000 messages were processed in 660ms.

CL-GSERVER> (log:config :warn)
CL-GSERVER> (time (iter:iter (iter:repeat 100000)
                    (call *my-server* :foo)))

Evaluation took:
  0.660 seconds of real time
  1.115068 seconds of total run time (0.899642 user, 0.215426 system)
  [ Run times consist of 0.013 seconds GC time, and 1.103 seconds non-GC time. ]
  168.94% CPU
  2,107,197,625 processor cycles
  80,363,168 bytes consed

Agent

Usage

An Agent is a specialized GServer. It is meant primarily for maintaining state and comes with some conveniences to do that.

To use an Agent import cl-gserver.agent package.

There is no need to subclass an Agent. An Agent provides three functions to use it.

All three take a lambda.
The lambda for make-agent does not take a parameter. It should return the initial state of the agent.
agent-get and agent-update both take a lambda that must support one parameter. This parameter represents the current state of the agent.

Let's make a simple example:

First create an agent with an initial state of 0.

(defparameter *my-agent* (make-agent (lambda () 0)))

Now update the state several times (agent-update is asynchronous and returns t immediately):

(agent-update *my-agent* (lambda (state) (1+ state)))

Finally get the state:

(agent-get *my-agent* #'identity)

This agent-get just uses the identity function to return the state as is.

So this simple agent represents a counter.

It is important to note that the retrieves state, i.e. with identity should not be modified outside the agent.

Wrapping an agent

While you can use the agent as in the example above it is usually advised to wrap an agent behind a more simple facade that doesn't work with lambdas.

For example could a facade for the counter above look like this:

(defvar *counter-agent* nil)

(defun init-agent (initial-value)
  (setf *counter-agent* (make-agent (lambda () initial-value))))

(defun increment () (agent-update *counter-agent* #'1+))
(defun decrement () (agent-update *counter-agent* #'1-))
(defun counter-value () (agent-get *counter-agent* #'identity))

Alternatively, one can wrap an agent inside a class and provide methods for simplified access to it.

Actor / Simple-Actor

Usage

Actors are another abstraction, or use-case of a GServer (GenServer). However, actors don't exist in Erlang. Actors are pretty much a GServer only that they provider only one method receive to handle both send (which is like cast) and ask (which is like call).
The cons return of receive is also a convention.

To use actors import the cl-gserver.actor package.

You have two choices to implement your actors.

1. Make your own subclass of actor and implement defmethod receive ... (see the actor-test.lisp for details).
2. Use the simple-actor convenience implementation

Let me make a simple ping-pong example here:

(I've added a local package name as act for cl-gserver.actor).

First create a ping actor:

(defparameter *ping* (act:make-actor "ping" 
                                     :state 0 
                                     :receive-fun
                                     (lambda (self msg state)
                                       (trivia:match msg
                                         ((cons :ping sender) (progn
                                                                (log:info "ping from: " sender)
                                                                (sleep 1)
                                                                (when (< state 5)
                                                                  (act:send sender (cons :pong self))
                                                                  (cons nil (1+ state)))))))))

The convenience make-actor function allows you to create a simple actor by specifying the receive-fun inline. Of course you may create a defun for the receive and specify it for :receive-fun like #'my-receive.
The important thing, it must accept three parameters. That is:

The receive-fun also must return a cons equal to the GServer with value for reply and new state.

Now let's create the pong actor:

(defparameter *pong* (act:make-actor "pong" 
                                     :receive-fun
                                     (lambda (self msg state)
                                     (trivia:match msg
                                       ((cons :pong sender) (progn
                                                              (log:info "pong from: " sender)
                                                              (sleep 1)
                                                              (act:send sender (cons :ping self))
                                                              (cons nil nil)))))))

Now we have two actors which can play ping pong.
We trigger it my sending a :ping to the *ping* actor but we also specify the *pong* actor as sender.

(act:send *ping* (cons :ping *pong*))

As can be seen on the *ping* actor definition, it will update it's state by incrementing the received pings. Once they are >= 5 it will stop sending a pong.


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 cl-gserver

Author

Manfred Bergmann

License

MIT

Description

Erlang inspired GenServer library with Agent for easy access to state.

Version

0.2.0

Dependencies
Source

cl-gserver.asd (file)

Component

src (module)


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

3 Modules

Modules are listed depth-first from the system components tree.


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

3.1 cl-gserver/src

Parent

cl-gserver (system)

Location

src/

Components

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

4 Files

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


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

4.1 Lisp


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

4.1.1 cl-gserver.asd

Location

cl-gserver.asd

Systems

cl-gserver (system)


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

4.1.2 cl-gserver/src/utils.lisp

Parent

src (module)

Location

src/utils.lisp

Packages

cl-gserver.utils

Exported Definitions

mkstr (function)


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

4.1.3 cl-gserver/src/gserver.lisp

Dependency

utils.lisp (file)

Parent

src (module)

Location

src/gserver.lisp

Packages

cl-gserver

Exported Definitions
Internal Definitions

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

4.1.4 cl-gserver/src/agent.lisp

Dependency

gserver.lisp (file)

Parent

src (module)

Location

src/agent.lisp

Packages

cl-gserver.agent

Exported Definitions

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

4.1.5 cl-gserver/src/actor.lisp

Dependency

agent.lisp (file)

Parent

src (module)

Location

src/actor.lisp

Packages

cl-gserver.actor

Exported Definitions
Internal Definitions

simple-actor (class)


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

5 Packages

Packages are listed by definition order.


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

5.1 cl-gserver.utils

Source

utils.lisp (file)

Nickname

utils

Use List

common-lisp

Used By List
Exported Definitions

mkstr (function)


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

5.2 cl-gserver

Source

gserver.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

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

5.3 cl-gserver.agent

Source

agent.lisp (file)

Use List
Exported Definitions

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

5.4 cl-gserver.actor

Source

actor.lisp (file)

Nickname

act

Use List
Exported Definitions
Internal Definitions

simple-actor (class)


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

6 Definitions

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


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

6.1 Exported definitions


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

6.1.1 Functions

Function: agent-get AGENT GET-FUN

Gets the current state of the ‘agent’.
‘get-fun’ must accept one parameter. That is the current-state of the ‘agent’. To return the current state ‘get-fun’ may be just the ‘identity’ function. See ‘agent-test’ for examples.

Package

cl-gserver.agent

Source

agent.lisp (file)

Function: agent-update AGENT UPDATE-FUN

Updates the ‘agent’ state.
‘update-fun’ must accept one parameter. That is the current state of the ‘agent’. The return value of ‘update-fun’ will be taken as the new state of the ‘agent’.

Package

cl-gserver.agent

Source

agent.lisp (file)

Function: ask ACTOR MESSAGE

Sends a message to the ‘actor’. ‘ask’ is synchronous and waits for a result.

Package

cl-gserver.actor

Source

actor.lisp (file)

Function: call GSERVER MESSAGE

Send a message to a gserver instance and wait for a result. The result can be of different types.
Success result: <returned-state>
Unhandled result: :unhandled
Error result: (cons :handler-error <error-description-as-string>)

Package

cl-gserver

Source

gserver.lisp (file)

Function: cast GSERVER MESSAGE

Sends a message to a gserver asynchronously. No result.

Package

cl-gserver

Source

gserver.lisp (file)

Function: init-dispatcher-threadpool SIZE
Package

cl-gserver

Source

gserver.lisp (file)

Function: make-actor NAME &key STATE RECEIVE-FUN

Makes a new ‘simple-actor’ which allows you to specify a name with ‘:state’ and ‘:receive-fun’.

Package

cl-gserver.actor

Source

actor.lisp (file)

Function: make-agent STATE-FUN

Makes a new ‘agent’ instance.
‘state-fun’ is a function that takes no parameter and provides the initial state of the ‘agent’ as return value.

Package

cl-gserver.agent

Source

agent.lisp (file)

Function: mkstr &rest ARGS

Converts all parameters to string and concatenates them.

Package

cl-gserver.utils

Source

utils.lisp (file)

Function: send ACTOR MESSAGE

Sends a message to the ‘actor’. ‘send’ is asynchronous.

Package

cl-gserver.actor

Source

actor.lisp (file)


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

6.1.2 Generic functions

Generic Function: handle-call GSERVER MESSAGE CURRENT-STATE

Handles calls to the server. Must be implemented by subclasses.
The convention here is to return a ‘cons’ with values to be returned to caller as ‘car’, and the new state as ‘cdr’. ‘handle-call’ is executed in the default message dispatcher thread.

Package

cl-gserver

Source

gserver.lisp (file)

Methods
Method: handle-call (SELF actor) MESSAGE CURRENT-STATE
Source

actor.lisp (file)

Method: handle-call (SELF agent) MESSAGE CURRENT-STATE
Source

agent.lisp (file)

Generic Function: handle-cast GSERVER MESSAGE CURRENT-STATE

Handles casts to the server. Must be implemented by subclasses.
Same convention as for ’handle-call’ except that no return is sent to the caller. This function returns immediately.

Package

cl-gserver

Source

gserver.lisp (file)

Methods
Method: handle-cast (SELF actor) MESSAGE CURRENT-STATE
Source

actor.lisp (file)

Method: handle-cast (SELF agent) MESSAGE CURRENT-STATE
Source

agent.lisp (file)

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

cl-gserver

Methods
Method: name (GSERVER gserver)
Method: (setf name) NEW-VALUE (GSERVER gserver)

The name of the gserver. If no name is specified a default one is applied.

Source

gserver.lisp (file)

Generic Function: receive ACTOR MESSAGE CURRENT-STATE

The ‘receive’ method handles all messages to an ‘actor’ being it ‘send’ or ‘ask’. But the convention persists that the result of ‘receive’ must be a ‘cons’ where ‘car’ is to be returned to the caller (for ‘ask’) and ‘cdr’ will update the state.

Package

cl-gserver.actor

Source

actor.lisp (file)

Methods
Method: receive (SELF simple-actor) MESSAGE CURRENT-STATE

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

6.1.3 Classes

Class: actor ()

Specialized ‘gserver’ class called ‘actor’.
There is a different terminology behind ‘actor’.
I.e. There is only one ‘receive’ function.
And there is asynchronous ‘send’ and synchronous ‘ask’.
So there is not much difference to a ‘gserver’.
It only uses one method ‘receive’. However both ‘handle-call’ and ‘handle-cast’ og ‘gserver’ end up in ‘receive’.

Package

cl-gserver.actor

Source

actor.lisp (file)

Direct superclasses

gserver (class)

Direct subclasses

simple-actor (class)

Direct methods
Class: agent ()

Specialized ‘gserver’ class called ‘agent’.
It is meant primarily to encapsulate state.
To access state it provides ‘agent-get’ and ‘agent-update’ to update state.

Package

cl-gserver.agent

Source

agent.lisp (file)

Direct superclasses

gserver (class)

Direct methods
Class: gserver ()

GServer is an Erlang inspired GenServer.
It is meant to encapsulate state, but also to execute async operations.
State can be changed by calling into the server via ‘call’ or ‘cast’.
Where ‘call’ is waiting for a result and ‘cast’ does not.
For each ‘call’ and ‘cast’ handlers must be implemented by subclasses.

A GServer runs it’s own thread, actually a lparallel message-kernel with one worker, to handle the messages which will eventually update the state.

Package

cl-gserver

Source

gserver.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
  • initialize-instance (method)
  • name (method)
  • name (method)
Direct slots
Slot: name

The name of the gserver. If no name is specified a default one is applied.

Initargs

:name

Initform

(cl-gserver.utils:mkstr "server-" (random 100000))

Readers

name (generic function)

Writers

(setf name) (generic function)

Slot: state

The encapsulated state.

Initargs

:state

Slot: message-kernel

The message-kernel with 1 worker for handling the messages.

Slot: message-channel

The message-channel for the message-kernel. Since we only have 1 worker here it is safe to make an instance channel regarding FIFO.

Slot: internal-state

The internal state of the server.

Initargs

:internal-state

Initform

(cl-gserver::make-gserver-state)


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

6.2 Internal definitions


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

6.2.1 Functions

Function: copy-gserver-state INSTANCE
Package

cl-gserver

Source

gserver.lisp (file)

Function: gserver-state-p OBJECT
Package

cl-gserver

Source

gserver.lisp (file)

Function: gserver-state-running INSTANCE
Function: (setf gserver-state-running) VALUE INSTANCE
Package

cl-gserver

Source

gserver.lisp (file)

Function: handle-message GSERVER MESSAGE WITHREPLY-P
Package

cl-gserver

Source

gserver.lisp (file)

Function: handle-message-internal MSG

Returns nil in order to make user handler being invoked.

Package

cl-gserver

Source

gserver.lisp (file)

Function: handle-message-user GSERVER MESSAGE WITHREPLY-P

This will call the method ’handle-call’ with the message.

Package

cl-gserver

Source

gserver.lisp (file)

Function: make-gserver-state &key (RUNNING RUNNING)
Package

cl-gserver

Source

gserver.lisp (file)

Function: process-handle-result HANDLE-RESULT GSERVER
Package

cl-gserver

Source

gserver.lisp (file)

Function: process-not-handled ()
Package

cl-gserver

Source

gserver.lisp (file)

Function: reply-value CONS-RESULT
Package

cl-gserver

Source

gserver.lisp (file)

Function: submit-message GSERVER MESSAGE WITHREPLY-P
Package

cl-gserver

Source

gserver.lisp (file)

Function: update-state GSERVER CONS-RESULT
Package

cl-gserver

Source

gserver.lisp (file)


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

6.2.2 Structures

Structure: gserver-state ()
Package

cl-gserver

Source

gserver.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: running
Type

boolean

Initform

t

Readers

gserver-state-running (function)

Writers

(setf gserver-state-running) (function)


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

6.2.3 Classes

Class: simple-actor ()

A simplified actor that can be created with just ‘make-actor’.

Package

cl-gserver.actor

Source

actor.lisp (file)

Direct superclasses

actor (class)

Direct methods

receive (method)

Direct slots
Slot: receive-fun

The receive function as specified as slot.

Initargs

:receive-fun


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   C   F   L   M  
Index Entry  Section

C
cl-gserver.asd: The cl-gserver․asd file
cl-gserver/src: The cl-gserver/src module
cl-gserver/src/actor.lisp: The cl-gserver/src/actor․lisp file
cl-gserver/src/agent.lisp: The cl-gserver/src/agent․lisp file
cl-gserver/src/gserver.lisp: The cl-gserver/src/gserver․lisp file
cl-gserver/src/utils.lisp: The cl-gserver/src/utils․lisp file

F
File, Lisp, cl-gserver.asd: The cl-gserver․asd file
File, Lisp, cl-gserver/src/actor.lisp: The cl-gserver/src/actor․lisp file
File, Lisp, cl-gserver/src/agent.lisp: The cl-gserver/src/agent․lisp file
File, Lisp, cl-gserver/src/gserver.lisp: The cl-gserver/src/gserver․lisp file
File, Lisp, cl-gserver/src/utils.lisp: The cl-gserver/src/utils․lisp file

L
Lisp File, cl-gserver.asd: The cl-gserver․asd file
Lisp File, cl-gserver/src/actor.lisp: The cl-gserver/src/actor․lisp file
Lisp File, cl-gserver/src/agent.lisp: The cl-gserver/src/agent․lisp file
Lisp File, cl-gserver/src/gserver.lisp: The cl-gserver/src/gserver․lisp file
Lisp File, cl-gserver/src/utils.lisp: The cl-gserver/src/utils․lisp file

M
Module, cl-gserver/src: The cl-gserver/src module

Jump to:   C   F   L   M  

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

A.2 Functions

Jump to:   (  
A   C   F   G   H   I   M   N   P   R   S   U  
Index Entry  Section

(
(setf gserver-state-running): Internal functions
(setf name): Exported generic functions
(setf name): Exported generic functions

A
agent-get: Exported functions
agent-update: Exported functions
ask: Exported functions

C
call: Exported functions
cast: Exported functions
copy-gserver-state: Internal functions

F
Function, (setf gserver-state-running): Internal functions
Function, agent-get: Exported functions
Function, agent-update: Exported functions
Function, ask: Exported functions
Function, call: Exported functions
Function, cast: Exported functions
Function, copy-gserver-state: Internal functions
Function, gserver-state-p: Internal functions
Function, gserver-state-running: Internal functions
Function, handle-message: Internal functions
Function, handle-message-internal: Internal functions
Function, handle-message-user: Internal functions
Function, init-dispatcher-threadpool: Exported functions
Function, make-actor: Exported functions
Function, make-agent: Exported functions
Function, make-gserver-state: Internal functions
Function, mkstr: Exported functions
Function, process-handle-result: Internal functions
Function, process-not-handled: Internal functions
Function, reply-value: Internal functions
Function, send: Exported functions
Function, submit-message: Internal functions
Function, update-state: Internal functions

G
Generic Function, (setf name): Exported generic functions
Generic Function, handle-call: Exported generic functions
Generic Function, handle-cast: Exported generic functions
Generic Function, name: Exported generic functions
Generic Function, receive: Exported generic functions
gserver-state-p: Internal functions
gserver-state-running: Internal functions

H
handle-call: Exported generic functions
handle-call: Exported generic functions
handle-call: Exported generic functions
handle-cast: Exported generic functions
handle-cast: Exported generic functions
handle-cast: Exported generic functions
handle-message: Internal functions
handle-message-internal: Internal functions
handle-message-user: Internal functions

I
init-dispatcher-threadpool: Exported functions

M
make-actor: Exported functions
make-agent: Exported functions
make-gserver-state: Internal functions
Method, (setf name): Exported generic functions
Method, handle-call: Exported generic functions
Method, handle-call: Exported generic functions
Method, handle-cast: Exported generic functions
Method, handle-cast: Exported generic functions
Method, name: Exported generic functions
Method, receive: Exported generic functions
mkstr: Exported functions

N
name: Exported generic functions
name: Exported generic functions

P
process-handle-result: Internal functions
process-not-handled: Internal functions

R
receive: Exported generic functions
receive: Exported generic functions
reply-value: Internal functions

S
send: Exported functions
submit-message: Internal functions

U
update-state: Internal functions

Jump to:   (  
A   C   F   G   H   I   M   N   P   R   S   U  

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

A.3 Variables

Jump to:   I   M   N   R   S  
Index Entry  Section

I
internal-state: Exported classes

M
message-channel: Exported classes
message-kernel: Exported classes

N
name: Exported classes

R
receive-fun: Internal classes
running: Internal structures

S
Slot, internal-state: Exported classes
Slot, message-channel: Exported classes
Slot, message-kernel: Exported classes
Slot, name: Exported classes
Slot, receive-fun: Internal classes
Slot, running: Internal structures
Slot, state: Exported classes
state: Exported classes

Jump to:   I   M   N   R   S  

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

A.4 Data types

Jump to:   A   C   G   P   S  
Index Entry  Section

A
actor: Exported classes
agent: Exported classes

C
cl-gserver: The cl-gserver system
cl-gserver: The cl-gserver package
cl-gserver.actor: The cl-gserver․actor package
cl-gserver.agent: The cl-gserver․agent package
cl-gserver.utils: The cl-gserver․utils package
Class, actor: Exported classes
Class, agent: Exported classes
Class, gserver: Exported classes
Class, simple-actor: Internal classes

G
gserver: Exported classes
gserver-state: Internal structures

P
Package, cl-gserver: The cl-gserver package
Package, cl-gserver.actor: The cl-gserver․actor package
Package, cl-gserver.agent: The cl-gserver․agent package
Package, cl-gserver.utils: The cl-gserver․utils package

S
simple-actor: Internal classes
Structure, gserver-state: Internal structures
System, cl-gserver: The cl-gserver system

Jump to:   A   C   G   P   S