The birch Reference Manual

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

The birch Reference Manual

This is the birch Reference Manual, version 1.0.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 03:16:48 2022 GMT+0.

Table of Contents


1 Introduction

Birch

Build Status Quicklisp

Birch is a simple Common Lisp IRC client library. It makes use of CLOS for event handling.

Dependencies

Birch is built in Common Lisp on SBCL. It depends on:

The tests also use Prove (MIT).

Installation

Birch can be loaded with Quicklisp:

(ql:quickload :birch)

Usage

The first step is to create a subclass of CONNECTION:

(defclass my-connection (connection) ())

To connect to an IRC network you create an instance of your connection class. You then pass that instance to CONNECT to actually connect to the network.

(defvar *connection* (make-instance 'my-connection
                                    :server-host "irc.example.com"
                                    :nick "mybot"))

The only required initargs for the default connection class are :SERVER-HOST and :NICK. The others of interest are:

The accessors for all of those are the name of the slot (the initarg without the ':').

Event handling in Birch is done by defining methods on HANDLE-EVENT.

(defgeneric handle-event (connection event)
  (:documentation "
Will be called after an IRC message has successfully been parsed and turned
into an event. Most IRC messages don't result in events, should you want to
handle them you can define a method on HANDLE-MESSAGE instead.")
  (:method-combination event))

For example, to do something when a PRIVMSG is received, you define a method specializing the first argument on your connection class and the second on the PRIVMSG-EVENT class:

(defmethod handle-event ((connection my-connection) (event privmsg-event))
  (format t "Message received on ~A: ~A" (channel event) (message event)))

A list of all the events currently included in Birch is below.

Sending commands to a connection can be done in two ways. You can use the generic function /RAW, which is basically a glorified FORMAT, or you can use one of the built-in functions for sending often-used commands. They're all generic functions and can thus easily be extended.

RAW can, for example, be called like this:

(/raw connection "JOIN ~A" channel)

But you should probably just use the function /JOIN in this case.

All currently implemented commands are listed below.

To start handling messages you should call PROCESS-MESSAGE-LOOP, which will block until the connection to the server is closed. Even then, if /QUIT wasn't called (so the ACTIVEP slot on the connection wasn't set to NIL) PROCESS-MESSAGE-LOOP will try to reconnect. You'll likely want to run this in a new thread.

Alternatively, you can call PROCESS-MESSAGE yourself.

We have to go deeper

If you want to handle a message from the server for which there is no event you can instead define a method on HANDLE-MESSAGE.

(defgeneric handle-message (connection prefix command params)
  (:documentation "
Called when a raw message is returned. CONNECTION is the connection object of
the connection the message was received on. PREFIX is a list of (NICK USER
HOST) COMMAND is a keyword, such as :PRIVMSG or :RPL_WELCOME PARAMS is a list
of parameters")
  (:method-combination event))

For example, to do something when RPL_WELCOME is received, you could define a method like so:

(defmethod handle-message ((connection my-connection)
                           prefix
                           (command (eql :RPL_WELCOME))
                           params)
  (format t "Received RPL_WELCOME, we can now do stuff"))

The COMMAND argument will either be the keyword-ized name of the command as defined in RFC2812, like :PRIVMSG, or, in the case of numeric replies, the name as found here.

If you want to handle something as an event you can define a method on HANDLE-MESSAGE that calls HANDLE-EVENT with a newly initialized EVENT object. The macro DEFINE-EVENT-DISPATCHER can be of great help with that.

(defmacro define-event-dispatcher (command class &optional positional-initargs)
  "Defines a method on HANDLE-MESSAGE to handle messages of which the command
is COMMAND. This new method will call HANDLE-EVENT with a new instance of type
CLASS.

POSITIONAL-INITARGS should be a list of initargs to pass to MAKE-INSTANCE,
where the position of the keyword determines the IRC command parameter that
will be used as a value. A NIL will cause an IRC parameter to be ignored.

For example, when POSITIONAL-INITARGS is (:CHANNEL), the first parameter of the
IRC message will be passed as the initial value of :CHANNEL. If
POSITIONAL-INITARGS is (:CHANNEL :TARGET), the first parameter will be passed
as the initial value of :CHANNEL, and the second parameter will be passed as
the initial value of :TARGET.

Instead of a keyword, an element of POSITIONAL-INITARGS can also be a list of
the form (:KEYWORD FUNCTION), which means the value passed as the initarg will
be the result of calling FUNCTION with two arguments: the connection object and
the IRC parameter.

Any remaining arguments will be joined together (separated by spaces) and
passed as the initial value of :MESSAGE."
  ...)

For example, kick events are implemented like this:

(defclass kick-event (channel-event)
  ((target :initarg :target
           :initform NIL
           :accessor target)))

(define-event-dispatcher :KICK 'kick-event ((:channel #'make-channel)
                                            (:target #'make-user)))

Events

Commands

Users and Channels

Birch keeps track of users and channels for you. The default events call MAKE-USER and MAKE-CHANNEL on the appropriate parameters, turning them into USER and CHANNEL objects with appropriate slots. To get a list of all users in a channel, call USERS on the channel object. Similarly, to get all channels a user is in (that we know of), call CHANNELS on a user object.

It is possible to change the class instantiated by MAKE-USER and MAKE-CHANNEL, by passing the desired class name to the :user-class or :channel-class initargs when creating the instance. This setting can also be changed after the fact with the accessors USER-CLASS and CHANNEL-CLASS.

It is worth noting that CONNECTION is itself a subclass of USER and will appear in channel user lists.

CTCP

Birch provides two utility functions for working with CTCP messages.

Notes

License

Copyright (c) 2015 Joram Schrijver

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

2 Systems

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


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

2.1 birch

A simple Common Lisp IRC client library

Author

Joram Schrijver <i@joram.io>

License

MIT

Version

1.0.1

Dependencies
  • split-sequence (system).
  • usocket (system).
  • flexi-streams (system).
  • alexandria (system).
  • cl+ssl (system).
Source

birch.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 birch/birch.asd

Source

birch.asd.

Parent Component

birch (system).

ASDF Systems

birch.


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

3.1.2 birch/replies.lisp

Source

birch.asd.

Parent Component

birch (system).

Packages

birch/replies.

Public Interface

reply->keyword (function).

Internals

*reply-codes* (special variable).


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

3.1.3 birch/parse.lisp

Source

birch.asd.

Parent Component

birch (system).

Packages

birch/parse.

Public Interface

3.1.4 birch/ctcp.lisp

Source

birch.asd.

Parent Component

birch (system).

Packages

birch/ctcp.

Public Interface

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

3.1.5 birch/connection.lisp

Source

birch.asd.

Parent Component

birch (system).

Packages

birch/connection.

Public Interface
Internals

3.1.6 birch/commands.lisp

Dependency

connection.lisp (file).

Source

birch.asd.

Parent Component

birch (system).

Packages

birch/commands.

Public Interface

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

3.1.7 birch/events.lisp

Dependencies
Source

birch.asd.

Parent Component

birch (system).

Packages

birch/events.

Public Interface

3.1.8 birch/init.lisp

Dependencies
Source

birch.asd.

Parent Component

birch (system).

Packages

birch/init.

Public Interface

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

3.1.9 birch/package.lisp

Dependencies
Source

birch.asd.

Parent Component

birch (system).

Packages

birch.


4 Packages

Packages are listed by definition order.


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

4.2 birch/events

Source

events.lisp.

Use List

common-lisp.

Used By List

birch.

Public Interface

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

4.3 birch/replies

Source

replies.lisp.

Use List

common-lisp.

Used By List
Public Interface

reply->keyword (function).

Internals

*reply-codes* (special variable).


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

4.4 birch/commands

Source

commands.lisp.

Use List

common-lisp.

Used By List

birch.

Public Interface

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

4.5 birch/ctcp

Source

ctcp.lisp.

Use List

common-lisp.

Used By List

birch.

Public Interface

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

4.6 birch/init

Source

init.lisp.

Use List
Used By List

birch.

Public Interface

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

4.7 birch/connection

Source

connection.lisp.

Use List

common-lisp.

Used By List
Public Interface
Internals

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

4.8 birch/parse

Source

parse.lisp.

Use List
Used By List
Public Interface

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


5.1.1 Macros

Macro: define-event-dispatcher (command class &optional positional-initargs)

Defines a method on HANDLE-MESSAGE to handle messages of which the command is COMMAND. This new method will call HANDLE-EVENT with a new instance of type CLASS.

POSITIONAL-INITARGS should be a list of initargs to pass to MAKE-INSTANCE, where the position of the keyword determines the IRC command parameter that will be used as a value. A NIL will cause an IRC parameter to be ignored.

For example, when POSITIONAL-INITARGS is (:CHANNEL), the first parameter of the IRC message will be passed as the initial value of :CHANNEL. If POSITIONAL-INITARGS is (:CHANNEL :TARGET), the first parameter will be passed as the initial value of :CHANNEL, and the second parameter will be passed as the initial value of :TARGET.

Instead of a keyword, an element of POSITIONAL-INITARGS can also be a list of the form (:KEYWORD FUNCTION), which means the value passed as the initarg will be the result of calling FUNCTION with two arguments: the connection object and the IRC parameter.

Any remaining arguments will be joined together (separated by spaces) and passed as the initial value of :MESSAGE.

Package

birch/events.

Source

events.lisp.


5.1.2 Ordinary functions

Function: add-user (user channel)
Package

birch/connection.

Source

connection.lisp.

Function: connect (connection)

Connects to the IRC network denoted by CONNECTION. Opens a connection to the server and performs initial registration.

Package

birch/init.

Source

init.lisp.

Function: connect-socket (connection)
Package

birch/connection.

Source

connection.lisp.

Function: ctcp-message-p (string)

Returns whether or not STRING is a valid CTCP message, by checking if it starts and ends with a 0x01 character.

Package

birch/ctcp.

Source

ctcp.lisp.

Function: make-channel (connection name)

Turn a channel name into a CHANNEL object. For unknown channels this will result in a new CHANNEL object, for ones that are already known the existing one will be returned. NIL is returned if NAME is not a valid channel name.

Package

birch/connection.

Source

connection.lisp.

Function: make-ctcp-message (string)

Returns a string with a 0x01 character added to the start and end of STRING, turning it into a CTCP message. The resulting string can then be sent to a connection using PRIVMSG or NOTICE

Package

birch/ctcp.

Source

ctcp.lisp.

Function: make-user (connection nick/prefix)

Turn a user’s nick or prefix into a USER object. For unknown users this will result in a new USER object, for ones that are already known the existing one will be returned. If the user is already known and NICK/PREFIX is a prefix with both a USER and HOST component, those slots of the user object will be updated.

Package

birch/connection.

Source

connection.lisp.

Function: parse-message (message)

Parses MESSAGE into a couple of parts:
- PREFIX as a list consisting of SOURCE, USER and HOST
- COMMAND as a keyword, numerics are converted to their keyword equivalent - PARAMS as a list of strings
The trailing argument, if available, will be the last item in PARAMS

Package

birch/parse.

Source

parse.lisp.

Function: parse-prefix (prefix)

Parses a prefix, assumed to still have the ’:’ at the front. Returns 3 values:
- NICK (or server name)
- USER
- HOST
Note that this function also succeeds when a user is supplied but not a host, even though that isn’t valid according to RFC2812.

Package

birch/parse.

Source

parse.lisp.

Function: process-message (connection)

Reads a message from CONNECTION and calls HANDLE-MESSAGE on it. Should probably be called in a loop. See PROCESS-MESSAGE-LOOP.

Package

birch/init.

Source

init.lisp.

Function: process-message-loop (connection)

Continuously calls READ-MESSAGE until the connection is closed.

Package

birch/init.

Source

init.lisp.

Function: read-message (connection)
Package

birch/init.

Source

init.lisp.

Function: remove-user (user &optional channel)
Package

birch/connection.

Source

connection.lisp.

Function: rename-user (connection old-nick new-nick)
Package

birch/connection.

Source

connection.lisp.

Function: reply->keyword (reply-code)

Turns a string representing a reply into an appropriate keyword. Numeric replies are converted to keywords based on their names as listed on https://www.alien.net.au/irc/irc2numerics.html Other replies are simply turned into keywords an returned.

Package

birch/replies.

Source

replies.lisp.


5.1.3 Generic functions

Generic Function: /invite (connection nick channel)

Sends an INVITE message to CONNECTION, trying to invite NICK to CHANNEL

Package

birch/commands.

Source

commands.lisp.

Methods
Method: /invite ((connection connection) (user string) (channel string))
Method: /invite ((connection connection) (user user) (channel channel))
Method: /invite ((connection connection) (user user) (channel string))
Method: /invite ((connection connection) (user string) (channel channel))
Generic Function: /join (connection channel &optional key)

Sends a JOIN message to CONNECTION, to join a channel.

Package

birch/commands.

Source

commands.lisp.

Methods
Method: /join ((connection connection) (channel string) &optional key)
Method: /join ((connection connection) (channel channel) &optional key)
Generic Function: /kick (connection channel nick &optional message)

Sends a KICK message to CONNECTION, trying to kick NICK from CHANNEL

Package

birch/commands.

Source

commands.lisp.

Methods
Method: /kick ((connection connection) (channel string) (user string) &optional message)
Method: /kick ((connection connection) (channel channel) (user user) &optional message)
Method: /kick ((connection connection) (channel string) (user user) &optional message)
Method: /kick ((connection connection) (channel channel) (user string) &optional message)
Generic Function: /nick (connection nick)

Sends a NICK message to CONNECTION, to change nicknames.

Package

birch/commands.

Source

commands.lisp.

Methods
Method: /nick ((connection connection) (nick string))
Generic Function: /notice (connection target message)

Sends a NOTICE message to CONNECTION. TARGET should either be a channel name or the name of a user connected to the network.

Package

birch/commands.

Source

commands.lisp.

Methods
Method: /notice ((connection connection) (target string) (message string))
Method: /notice ((connection connection) (target channel) (message string))
Method: /notice ((connection connection) (target user) (message string))
Generic Function: /part (connection channel &optional message)

Sends a PART message to CONNECTION, to leave a channel.

Package

birch/commands.

Source

commands.lisp.

Methods
Method: /part ((connection connection) (channel string) &optional message)
Method: /part ((connection connection) (channel channel) &optional message)
Generic Function: /pass (connection pass)

Sends a PASS message to CONNECTION, for the purpose of registration.

Package

birch/commands.

Source

commands.lisp.

Methods
Method: /pass ((connection connection) pass)
Generic Function: /pong (connection server-1 &optional server-2)

Sends a PONG message to CONNECTION, usually in reply to a PING by the server

Package

birch/commands.

Source

commands.lisp.

Methods
Method: /pong ((connection connection) (server-1 string) &optional server-2)
Generic Function: /privmsg (connection channel message)

Sends a PRIVMSG message to CONNECTION. CHANNEL should either be a channel name or the name of a user connected to the network.

Package

birch/commands.

Source

commands.lisp.

Methods
Method: /privmsg ((connection connection) (channel string) (message string))
Method: /privmsg ((connection connection) (channel channel) (message string))
Method: /privmsg ((connection connection) (user user) (message string))
Generic Function: /quit (connection &optional message)

Sends a QUIT message to CONNECTION and sets (ACTIVEP CONNECTION) to T, which will stop READ-MESSAGE-LOOP from trying to reconnect

Package

birch/commands.

Source

commands.lisp.

Methods
Method: /quit ((connection connection) &optional message)
Generic Function: /raw (connection message &rest format-arguments)

Sends MESSAGE to the stream associated with CONNECTION, after applying FORMAT to message with FORMAT-ARGUMENTS.

Package

birch/commands.

Source

commands.lisp.

Methods
Method: /raw ((connection connection) (message string) &rest format-arguments)
Generic Function: /user (connection user mode real-name)

Sends a USER message to CONNECTION, for the purpose of registration. Note that the IRC USER command also takes another parameter between MODE and REAL-NAME, but this parameter is unused.

Package

birch/commands.

Source

commands.lisp.

Methods
Method: /user ((connection connection) (user string) (mode integer) (real-name string))
Generic Function: /who (connection target &optional operators-only-p)

Sends a WHO message to CONNECTION about TARGET, optionally requesting operators only. TARGET can be either a user, channel, or string representing the desired mask.

Package

birch/commands.

Source

commands.lisp.

Methods
Method: /who ((connection connection) (target string) &optional operators-only-p)
Method: /who ((connection connection) (target user) &optional operators-only-p)
Method: /who ((connection connection) (target channel) &optional operators-only-p)
Generic Reader: activep (object)
Generic Writer: (setf activep) (object)
Package

birch/connection.

Methods
Reader Method: activep ((connection connection))
Writer Method: (setf activep) ((connection connection))

Whether or not the connection to the server is supposed to be open. In case of connection issues READ-MESSAGE-LOOP uses this to determine whether or not to reconnect

Source

connection.lisp.

Target Slot

activep.

Generic Reader: channel (object)
Package

birch/connection.

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

automatically generated reader method

Source

events.lisp.

Target Slot

channel.

Generic Writer: (setf channel) (object)
Package

birch/connection.

Methods
Writer Method: (setf channel) ((channel-event channel-event))

automatically generated writer method

Source

events.lisp.

Target Slot

channel.

Generic Reader: channel-class (object)
Package

birch/connection.

Methods
Reader Method: channel-class ((connection connection))

automatically generated reader method

Source

connection.lisp.

Target Slot

channel-class.

Generic Writer: (setf channel-class) (object)
Package

birch/connection.

Methods
Writer Method: (setf channel-class) ((connection connection))

automatically generated writer method

Source

connection.lisp.

Target Slot

channel-class.

Generic Reader: channel-type (object)
Package

birch/connection.

Methods
Reader Method: channel-type ((channel channel))

automatically generated reader method

Source

connection.lisp.

Target Slot

channel-type.

Generic Writer: (setf channel-type) (object)
Package

birch/connection.

Methods
Writer Method: (setf channel-type) ((channel channel))

automatically generated writer method

Source

connection.lisp.

Target Slot

channel-type.

Generic Reader: channels (object)
Package

birch/connection.

Methods
Reader Method: channels ((user user))

automatically generated reader method

Source

connection.lisp.

Target Slot

channels.

Generic Writer: (setf channels) (object)
Package

birch/connection.

Methods
Writer Method: (setf channels) ((user user))

automatically generated writer method

Source

connection.lisp.

Target Slot

channels.

Generic Reader: connection (object)
Package

birch/connection.

Methods
Reader Method: connection ((channel channel))

automatically generated reader method

Source

connection.lisp.

Target Slot

connection.

Reader Method: connection ((user user))

automatically generated reader method

Source

connection.lisp.

Target Slot

connection.

Generic Writer: (setf connection) (object)
Package

birch/connection.

Methods
Writer Method: (setf connection) ((user user))

automatically generated writer method

Source

connection.lisp.

Target Slot

connection.

Generic Function: handle-event (connection event)

Will be called after an IRC message has successfully been parsed and turned into an event. Most IRC messages don’t result in events, should you want to handle them you can define a method on HANDLE-MESSAGE instead.

Package

birch/events.

Source

events.lisp.

Method Combination

event.

Methods
Method: handle-event ((connection connection) (event kick-event))

Remove a user from a channel they’re kicked from.

Method: handle-event ((connection connection) (event quit-event))

Remove a user from all channels they’re in.

Method: handle-event ((connection connection) (event part-event))

Remove a user from a channel they’re leaving.

Method: handle-event ((connection connection) (event join-event))

Add a user to a channel.

Method: handle-event ((connection connection) (event topic-event))

Change the topic associated with a channel.

Method: handle-event ((connection connection) (event nick-event))

Change the nickname associated with a user, or of the connection if the old nickname is the nickname of the connection.

Generic Function: handle-message (connection prefix command params)

Called when a raw message is returned. CONNECTION is the connection object of the connection the message was received on. PREFIX is a list of (NICK USER HOST) COMMAND is a keyword, such as :PRIVMSG or :RPL_WELCOME PARAMS is a list of parameters

Package

birch/events.

Source

events.lisp.

Method Combination

event.

Methods
Method: handle-message ((connection connection) prefix (command (eql :rpl_topic)) params)
Method: handle-message ((connection connection) prefix (command (eql :topic)) params)
Method: handle-message ((connection connection) prefix (command (eql :nick)) params)
Method: handle-message ((connection connection) prefix (command (eql :kick)) params)
Method: handle-message ((connection connection) prefix (command (eql :quit)) params)
Method: handle-message ((connection connection) prefix (command (eql :part)) params)
Method: handle-message ((connection connection) prefix (command (eql :join)) params)
Method: handle-message ((connection connection) prefix (command (eql :notice)) params)
Method: handle-message ((connection connection) prefix (command (eql :privmsg)) params)
Method: handle-message ((connection connection) prefix (command (eql :rpl_whoreply)) params)

Handles an RPL_WHOREPLY message and updates the users and channels associated.

Method: handle-message ((connection connection) prefix (command (eql :rpl_namreply)) params)

Handles an RPL_NAMREPLY message and updates the channel.

Method: handle-message ((connection connection) prefix (command (eql :ping)) params)

Responds to a PING message by the server by sending a PONG message in return

Generic Reader: host (object)
Package

birch/connection.

Methods
Reader Method: host ((user user))

automatically generated reader method

Source

connection.lisp.

Target Slot

host.

Generic Writer: (setf host) (object)
Package

birch/connection.

Methods
Writer Method: (setf host) ((user user))

automatically generated writer method

Source

connection.lisp.

Target Slot

host.

Generic Reader: message (object)
Package

birch/events.

Methods
Reader Method: message ((event event))

automatically generated reader method

Source

events.lisp.

Target Slot

message.

Generic Writer: (setf message) (object)
Package

birch/events.

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

automatically generated writer method

Source

events.lisp.

Target Slot

message.

Generic Reader: name (object)
Package

birch/connection.

Methods
Reader Method: name ((channel channel))

automatically generated reader method

Source

connection.lisp.

Target Slot

name.

Generic Reader: new-nick (object)
Package

birch/events.

Methods
Reader Method: new-nick ((nick-event nick-event))

automatically generated reader method

Source

events.lisp.

Target Slot

new-nick.

Generic Writer: (setf new-nick) (object)
Package

birch/events.

Methods
Writer Method: (setf new-nick) ((nick-event nick-event))

automatically generated writer method

Source

events.lisp.

Target Slot

new-nick.

Generic Reader: new-topic (object)
Package

birch/events.

Methods
Reader Method: new-topic ((topic-event topic-event))

automatically generated reader method

Source

events.lisp.

Target Slot

new-topic.

Generic Writer: (setf new-topic) (object)
Package

birch/events.

Methods
Writer Method: (setf new-topic) ((topic-event topic-event))

automatically generated writer method

Source

events.lisp.

Target Slot

new-topic.

Generic Reader: nick (object)
Package

birch/connection.

Methods
Reader Method: nick ((user user))

automatically generated reader method

Source

connection.lisp.

Target Slot

nick.

Generic Writer: (setf nick) (object)
Package

birch/connection.

Methods
Writer Method: (setf nick) ((user user))

automatically generated writer method

Source

connection.lisp.

Target Slot

nick.

Generic Reader: pass (object)
Package

birch/connection.

Methods
Reader Method: pass ((connection connection))

automatically generated reader method

Source

connection.lisp.

Target Slot

pass.

Generic Writer: (setf pass) (object)
Package

birch/connection.

Methods
Writer Method: (setf pass) ((connection connection))

automatically generated writer method

Source

connection.lisp.

Target Slot

pass.

Generic Reader: real-name (object)
Package

birch/connection.

Methods
Reader Method: real-name ((connection connection))

automatically generated reader method

Source

connection.lisp.

Target Slot

real-name.

Generic Writer: (setf real-name) (object)
Package

birch/connection.

Methods
Writer Method: (setf real-name) ((connection connection))

automatically generated writer method

Source

connection.lisp.

Target Slot

real-name.

Generic Reader: server-host (object)
Package

birch/connection.

Methods
Reader Method: server-host ((connection connection))

automatically generated reader method

Source

connection.lisp.

Target Slot

server-host.

Generic Reader: server-port (object)
Package

birch/connection.

Methods
Reader Method: server-port ((connection connection))

automatically generated reader method

Source

connection.lisp.

Target Slot

server-port.

Generic Writer: (setf server-port) (object)
Package

birch/connection.

Methods
Writer Method: (setf server-port) ((connection connection))

automatically generated writer method

Source

connection.lisp.

Target Slot

server-port.

Generic Reader: socket-stream (object)
Generic Writer: (setf socket-stream) (object)
Package

birch/connection.

Methods
Reader Method: socket-stream ((connection connection))
Writer Method: (setf socket-stream) ((connection connection))

The stream associated with the current socket connection to the server.

Source

connection.lisp.

Target Slot

socket-stream.

Generic Reader: target (object)
Package

birch/events.

Methods
Reader Method: target ((kick-event kick-event))

automatically generated reader method

Source

events.lisp.

Target Slot

target.

Generic Writer: (setf target) (object)
Package

birch/events.

Methods
Writer Method: (setf target) ((kick-event kick-event))

automatically generated writer method

Source

events.lisp.

Target Slot

target.

Generic Reader: topic (object)
Package

birch/connection.

Methods
Reader Method: topic ((channel channel))

automatically generated reader method

Source

connection.lisp.

Target Slot

topic.

Generic Writer: (setf topic) (object)
Package

birch/connection.

Methods
Writer Method: (setf topic) ((channel channel))

automatically generated writer method

Source

connection.lisp.

Target Slot

topic.

Generic Reader: user (object)
Package

birch/connection.

Methods
Reader Method: user ((event event))

automatically generated reader method

Source

events.lisp.

Target Slot

user.

Reader Method: user ((user user))

automatically generated reader method

Source

connection.lisp.

Target Slot

user.

Generic Writer: (setf user) (object)
Package

birch/connection.

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

automatically generated writer method

Source

events.lisp.

Target Slot

user.

Writer Method: (setf user) ((user user))

automatically generated writer method

Source

connection.lisp.

Target Slot

user.

Generic Reader: user-class (object)
Package

birch/connection.

Methods
Reader Method: user-class ((connection connection))

automatically generated reader method

Source

connection.lisp.

Target Slot

user-class.

Generic Writer: (setf user-class) (object)
Package

birch/connection.

Methods
Writer Method: (setf user-class) ((connection connection))

automatically generated writer method

Source

connection.lisp.

Target Slot

user-class.

Generic Reader: users (object)
Package

birch/connection.

Methods
Reader Method: users ((connection connection))

automatically generated reader method

Source

connection.lisp.

Target Slot

users.

Reader Method: users ((channel channel))

automatically generated reader method

Source

connection.lisp.

Target Slot

users.

Generic Writer: (setf users) (object)
Package

birch/connection.

Methods
Writer Method: (setf users) ((connection connection))

automatically generated writer method

Source

connection.lisp.

Target Slot

users.

Writer Method: (setf users) ((channel channel))

automatically generated writer method

Source

connection.lisp.

Target Slot

users.


5.1.4 Standalone methods

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

connection.lisp.


5.1.5 Method combinations

Method Combination: event ()

The EVENT method combination is used by HANDLE-MESSAGE and HANDLE-EVENT to gracefully handle the absence of message or event handlers. In standard method combination, when only a non-primary method exists, an error is signalled. This makes it very hard to handle errors through an :AROUND method, which would be the most elegant solution to the problem. This method combination is just like the standard one, except primary methods are not required.

Package

birch/events.

Source

events.lisp.

Client Functions

5.1.6 Classes

Class: channel
Package

birch/connection.

Source

connection.lisp.

Direct methods
Direct slots
Slot: connection
Initargs

:connection

Readers

connection.

Writers

This slot is read-only.

Slot: name
Initargs

:name

Readers

name.

Writers

This slot is read-only.

Slot: users
Initargs

:users

Readers

users.

Writers

(setf users).

Slot: topic
Initform

""

Initargs

:topic

Readers

topic.

Writers

(setf topic).

Slot: channel-type
Type

birch/connection:channel-type

Initargs

:channel-type

Readers

channel-type.

Writers

(setf channel-type).

Class: channel-event

A CHANNEL-EVENT is an event that happens on a certain channel.

Package

birch/events.

Source

events.lisp.

Direct superclasses

event.

Direct subclasses
Direct methods
Direct slots
Slot: channel
Package

birch/connection.

Initargs

:channel

Readers

channel.

Writers

(setf channel).

Class: connection
Package

birch/connection.

Source

connection.lisp.

Direct superclasses

user.

Direct methods
Direct Default Initargs
InitargValue
:nick(error nick required, not specified)
Direct slots
Slot: %socket

An instance of USOCKET:STREAM-USOCKET, the current socket connection to the server.

Initargs

:socket

Readers

%socket.

Writers

(setf %socket).

Slot: socket-stream

The stream associated with the current socket connection to the server.

Initargs

:stream

Readers

socket-stream.

Writers

(setf socket-stream).

Slot: activep

Whether or not the connection to the server is supposed to be open. In case of connection issues READ-MESSAGE-LOOP uses this to determine whether or not to reconnect

Initargs

:activep

Readers

activep.

Writers

(setf activep).

Slot: server-host
Initform

(error "host required, not specified")

Initargs

:server-host

Readers

server-host.

Writers

This slot is read-only.

Slot: server-port
Initform

6667

Initargs

:server-port

Readers

server-port.

Writers

(setf server-port).

Slot: ssl

Whether to use SSL for the IRC connection.

Initargs

:ssl

Readers

ssl.

Writers

(setf ssl).

Slot: ssl-verify

Whether to verify the SSL hostname.

Initform

t

Initargs

:ssl

Readers

ssl-verify.

Writers

(setf ssl-verify).

Slot: pass
Initargs

:pass

Readers

pass.

Writers

(setf pass).

Slot: real-name
Initform

"birch irc library"

Initargs

:real-name

Readers

real-name.

Writers

(setf real-name).

Slot: users
Initargs

:users

Readers

users.

Writers

(setf users).

Slot: user-class
Initform

(quote birch/connection:user)

Initargs

:user-class

Readers

user-class.

Writers

(setf user-class).

Slot: channel-class
Initform

(quote birch/connection:channel)

Initargs

:channel-class

Readers

channel-class.

Writers

(setf channel-class).

Class: event
Package

birch/events.

Source

events.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: user
Package

birch/connection.

Initargs

:user

Readers

user.

Writers

(setf user).

Slot: message
Initargs

:message

Readers

message.

Writers

(setf message).

Class: join-event
Package

birch/events.

Source

events.lisp.

Direct superclasses

channel-event.

Direct methods

handle-event.

Class: kick-event
Package

birch/events.

Source

events.lisp.

Direct superclasses

channel-event.

Direct methods
Direct slots
Slot: target
Initargs

:target

Readers

target.

Writers

(setf target).

Class: nick-event
Package

birch/events.

Source

events.lisp.

Direct superclasses

event.

Direct methods
Direct slots
Slot: new-nick
Initargs

:new-nick

Readers

new-nick.

Writers

(setf new-nick).

Class: notice-event

Event dispatched when a NOTICE message is received from the server. Note that when the CHANNEL slot is STRING= to the current nickname this notice won’t have been sent to a channel but directly to you.

Package

birch/events.

Source

events.lisp.

Direct superclasses

channel-event.

Class: part-event
Package

birch/events.

Source

events.lisp.

Direct superclasses

channel-event.

Direct methods

handle-event.

Class: privmsg-event

Event dispatched when a PRIVMSG message is received from the server. Note that when the CHANNEL slot is STRING= to the current nickname this privmsg won’t have been sent to a channel but directly to you.

Package

birch/events.

Source

events.lisp.

Direct superclasses

channel-event.

Class: quit-event
Package

birch/events.

Source

events.lisp.

Direct superclasses

event.

Direct methods

handle-event.

Class: topic-event
Package

birch/events.

Source

events.lisp.

Direct superclasses

channel-event.

Direct methods
Direct slots
Slot: new-topic
Initargs

:new-topic

Readers

new-topic.

Writers

(setf new-topic).

Class: user
Package

birch/connection.

Source

connection.lisp.

Direct subclasses

connection.

Direct methods
Direct slots
Slot: connection
Initargs

:connection

Readers

connection.

Writers

(setf connection).

Slot: nick
Initargs

:nick

Readers

nick.

Writers

(setf nick).

Slot: user
Initargs

:user

Readers

user.

Writers

(setf user).

Slot: host
Initargs

:host

Readers

host.

Writers

(setf host).

Slot: channels
Initargs

:channels

Readers

channels.

Writers

(setf channels).


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

5.1.7 Types

Type: channel-type ()
Package

birch/connection.

Source

connection.lisp.


5.2 Internals


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

5.2.1 Special variables

Special Variable: *reply-codes*

Hash-table filled with all numeric IRC reply codes, taken from https://www.alien.net.au/irc/irc2numerics.html

Package

birch/replies.

Source

replies.lisp.


5.2.2 Ordinary functions

Function: get-channel (connection name)
Package

birch/connection.

Source

connection.lisp.

Function: get-user (connection nick &optional user host)
Package

birch/connection.

Source

connection.lisp.

Function: valid-channel-name-p (name)
Package

birch/connection.

Source

connection.lisp.


5.2.3 Generic functions

Generic Reader: %socket (object)
Generic Writer: (setf %socket) (object)
Package

birch/connection.

Methods
Reader Method: %socket ((connection connection))
Writer Method: (setf %socket) ((connection connection))

An instance of USOCKET:STREAM-USOCKET, the current socket connection to the server.

Source

connection.lisp.

Target Slot

%socket.

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

birch/connection.

Methods
Reader Method: ssl ((connection connection))
Writer Method: (setf ssl) ((connection connection))

Whether to use SSL for the IRC connection.

Source

connection.lisp.

Target Slot

ssl.

Generic Reader: ssl-verify (object)
Generic Writer: (setf ssl-verify) (object)
Package

birch/connection.

Methods
Reader Method: ssl-verify ((connection connection))
Writer Method: (setf ssl-verify) ((connection connection))

Whether to verify the SSL hostname.

Source

connection.lisp.

Target Slot

ssl-verify.


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   %   (   /  
A   C   D   E   F   G   H   I   M   N   P   R   S   T   U   V  
Index Entry  Section

%
%socket: Private generic functions
%socket: Private generic functions

(
(setf %socket): Private generic functions
(setf %socket): Private generic functions
(setf activep): Public generic functions
(setf activep): Public generic functions
(setf channel): Public generic functions
(setf channel): Public generic functions
(setf channel-class): Public generic functions
(setf channel-class): Public generic functions
(setf channel-type): Public generic functions
(setf channel-type): Public generic functions
(setf channels): Public generic functions
(setf channels): Public generic functions
(setf connection): Public generic functions
(setf connection): Public generic functions
(setf host): Public generic functions
(setf host): Public generic functions
(setf message): Public generic functions
(setf message): Public generic functions
(setf new-nick): Public generic functions
(setf new-nick): Public generic functions
(setf new-topic): Public generic functions
(setf new-topic): Public generic functions
(setf nick): Public generic functions
(setf nick): Public generic functions
(setf pass): Public generic functions
(setf pass): Public generic functions
(setf real-name): Public generic functions
(setf real-name): Public generic functions
(setf server-port): Public generic functions
(setf server-port): Public generic functions
(setf socket-stream): Public generic functions
(setf socket-stream): Public generic functions
(setf ssl): Private generic functions
(setf ssl): Private generic functions
(setf ssl-verify): Private generic functions
(setf ssl-verify): Private generic functions
(setf target): Public generic functions
(setf target): Public generic functions
(setf topic): Public generic functions
(setf topic): Public generic functions
(setf user): Public generic functions
(setf user): Public generic functions
(setf user): Public generic functions
(setf user-class): Public generic functions
(setf user-class): Public generic functions
(setf users): Public generic functions
(setf users): Public generic functions
(setf users): Public generic functions

/
/invite: Public generic functions
/invite: Public generic functions
/invite: Public generic functions
/invite: Public generic functions
/invite: Public generic functions
/join: Public generic functions
/join: Public generic functions
/join: Public generic functions
/kick: Public generic functions
/kick: Public generic functions
/kick: Public generic functions
/kick: Public generic functions
/kick: Public generic functions
/nick: Public generic functions
/nick: Public generic functions
/notice: Public generic functions
/notice: Public generic functions
/notice: Public generic functions
/notice: Public generic functions
/part: Public generic functions
/part: Public generic functions
/part: Public generic functions
/pass: Public generic functions
/pass: Public generic functions
/pong: Public generic functions
/pong: Public generic functions
/privmsg: Public generic functions
/privmsg: Public generic functions
/privmsg: Public generic functions
/privmsg: Public generic functions
/quit: Public generic functions
/quit: Public generic functions
/raw: Public generic functions
/raw: Public generic functions
/user: Public generic functions
/user: Public generic functions
/who: Public generic functions
/who: Public generic functions
/who: Public generic functions
/who: Public generic functions

A
activep: Public generic functions
activep: Public generic functions
add-user: Public ordinary functions

C
channel: Public generic functions
channel: Public generic functions
channel-class: Public generic functions
channel-class: Public generic functions
channel-type: Public generic functions
channel-type: Public generic functions
channels: Public generic functions
channels: Public generic functions
connect: Public ordinary functions
connect-socket: Public ordinary functions
connection: Public generic functions
connection: Public generic functions
connection: Public generic functions
ctcp-message-p: Public ordinary functions

D
define-event-dispatcher: Public macros

E
event: Public method combinations

F
Function, add-user: Public ordinary functions
Function, connect: Public ordinary functions
Function, connect-socket: Public ordinary functions
Function, ctcp-message-p: Public ordinary functions
Function, get-channel: Private ordinary functions
Function, get-user: Private ordinary functions
Function, make-channel: Public ordinary functions
Function, make-ctcp-message: Public ordinary functions
Function, make-user: Public ordinary functions
Function, parse-message: Public ordinary functions
Function, parse-prefix: Public ordinary functions
Function, process-message: Public ordinary functions
Function, process-message-loop: Public ordinary functions
Function, read-message: Public ordinary functions
Function, remove-user: Public ordinary functions
Function, rename-user: Public ordinary functions
Function, reply->keyword: Public ordinary functions
Function, valid-channel-name-p: Private ordinary functions

G
Generic Function, %socket: Private generic functions
Generic Function, (setf %socket): Private generic functions
Generic Function, (setf activep): Public generic functions
Generic Function, (setf channel): Public generic functions
Generic Function, (setf channel-class): Public generic functions
Generic Function, (setf channel-type): Public generic functions
Generic Function, (setf channels): Public generic functions
Generic Function, (setf connection): Public generic functions
Generic Function, (setf host): Public generic functions
Generic Function, (setf message): Public generic functions
Generic Function, (setf new-nick): Public generic functions
Generic Function, (setf new-topic): Public generic functions
Generic Function, (setf nick): Public generic functions
Generic Function, (setf pass): Public generic functions
Generic Function, (setf real-name): Public generic functions
Generic Function, (setf server-port): Public generic functions
Generic Function, (setf socket-stream): Public generic functions
Generic Function, (setf ssl): Private generic functions
Generic Function, (setf ssl-verify): Private generic functions
Generic Function, (setf target): Public generic functions
Generic Function, (setf topic): Public generic functions
Generic Function, (setf user): Public generic functions
Generic Function, (setf user-class): Public generic functions
Generic Function, (setf users): Public generic functions
Generic Function, /invite: Public generic functions
Generic Function, /join: Public generic functions
Generic Function, /kick: Public generic functions
Generic Function, /nick: Public generic functions
Generic Function, /notice: Public generic functions
Generic Function, /part: Public generic functions
Generic Function, /pass: Public generic functions
Generic Function, /pong: Public generic functions
Generic Function, /privmsg: Public generic functions
Generic Function, /quit: Public generic functions
Generic Function, /raw: Public generic functions
Generic Function, /user: Public generic functions
Generic Function, /who: Public generic functions
Generic Function, activep: Public generic functions
Generic Function, channel: Public generic functions
Generic Function, channel-class: Public generic functions
Generic Function, channel-type: Public generic functions
Generic Function, channels: Public generic functions
Generic Function, connection: Public generic functions
Generic Function, handle-event: Public generic functions
Generic Function, handle-message: Public generic functions
Generic Function, host: Public generic functions
Generic Function, message: Public generic functions
Generic Function, name: Public generic functions
Generic Function, new-nick: Public generic functions
Generic Function, new-topic: Public generic functions
Generic Function, nick: Public generic functions
Generic Function, pass: Public generic functions
Generic Function, real-name: Public generic functions
Generic Function, server-host: Public generic functions
Generic Function, server-port: Public generic functions
Generic Function, socket-stream: Public generic functions
Generic Function, ssl: Private generic functions
Generic Function, ssl-verify: Private generic functions
Generic Function, target: Public generic functions
Generic Function, topic: Public generic functions
Generic Function, user: Public generic functions
Generic Function, user-class: Public generic functions
Generic Function, users: Public generic functions
get-channel: Private ordinary functions
get-user: Private ordinary functions

H
handle-event: Public generic functions
handle-event: Public generic functions
handle-event: Public generic functions
handle-event: Public generic functions
handle-event: Public generic functions
handle-event: Public generic functions
handle-event: Public generic functions
handle-message: Public generic functions
handle-message: Public generic functions
handle-message: Public generic functions
handle-message: Public generic functions
handle-message: Public generic functions
handle-message: Public generic functions
handle-message: Public generic functions
handle-message: Public generic functions
handle-message: Public generic functions
handle-message: Public generic functions
handle-message: Public generic functions
handle-message: Public generic functions
handle-message: Public generic functions
host: Public generic functions
host: Public generic functions

I
initialize-instance: Public standalone methods

M
Macro, define-event-dispatcher: Public macros
make-channel: Public ordinary functions
make-ctcp-message: Public ordinary functions
make-user: Public ordinary functions
message: Public generic functions
message: Public generic functions
Method Combination, event: Public method combinations
Method, %socket: Private generic functions
Method, (setf %socket): Private generic functions
Method, (setf activep): Public generic functions
Method, (setf channel): Public generic functions
Method, (setf channel-class): Public generic functions
Method, (setf channel-type): Public generic functions
Method, (setf channels): Public generic functions
Method, (setf connection): Public generic functions
Method, (setf host): Public generic functions
Method, (setf message): Public generic functions
Method, (setf new-nick): Public generic functions
Method, (setf new-topic): Public generic functions
Method, (setf nick): Public generic functions
Method, (setf pass): Public generic functions
Method, (setf real-name): Public generic functions
Method, (setf server-port): Public generic functions
Method, (setf socket-stream): Public generic functions
Method, (setf ssl): Private generic functions
Method, (setf ssl-verify): Private generic functions
Method, (setf target): Public generic functions
Method, (setf topic): Public generic functions
Method, (setf user): Public generic functions
Method, (setf user): Public generic functions
Method, (setf user-class): Public generic functions
Method, (setf users): Public generic functions
Method, (setf users): Public generic functions
Method, /invite: Public generic functions
Method, /invite: Public generic functions
Method, /invite: Public generic functions
Method, /invite: Public generic functions
Method, /join: Public generic functions
Method, /join: Public generic functions
Method, /kick: Public generic functions
Method, /kick: Public generic functions
Method, /kick: Public generic functions
Method, /kick: Public generic functions
Method, /nick: Public generic functions
Method, /notice: Public generic functions
Method, /notice: Public generic functions
Method, /notice: Public generic functions
Method, /part: Public generic functions
Method, /part: Public generic functions
Method, /pass: Public generic functions
Method, /pong: Public generic functions
Method, /privmsg: Public generic functions
Method, /privmsg: Public generic functions
Method, /privmsg: Public generic functions
Method, /quit: Public generic functions
Method, /raw: Public generic functions
Method, /user: Public generic functions
Method, /who: Public generic functions
Method, /who: Public generic functions
Method, /who: Public generic functions
Method, activep: Public generic functions
Method, channel: Public generic functions
Method, channel-class: Public generic functions
Method, channel-type: Public generic functions
Method, channels: Public generic functions
Method, connection: Public generic functions
Method, connection: Public generic functions
Method, handle-event: Public generic functions
Method, handle-event: Public generic functions
Method, handle-event: Public generic functions
Method, handle-event: Public generic functions
Method, handle-event: Public generic functions
Method, handle-event: Public generic functions
Method, handle-message: Public generic functions
Method, handle-message: Public generic functions
Method, handle-message: Public generic functions
Method, handle-message: Public generic functions
Method, handle-message: Public generic functions
Method, handle-message: Public generic functions
Method, handle-message: Public generic functions
Method, handle-message: Public generic functions
Method, handle-message: Public generic functions
Method, handle-message: Public generic functions
Method, handle-message: Public generic functions
Method, handle-message: Public generic functions
Method, host: Public generic functions
Method, initialize-instance: Public standalone methods
Method, message: Public generic functions
Method, name: Public generic functions
Method, new-nick: Public generic functions
Method, new-topic: Public generic functions
Method, nick: Public generic functions
Method, pass: Public generic functions
Method, real-name: Public generic functions
Method, server-host: Public generic functions
Method, server-port: Public generic functions
Method, socket-stream: Public generic functions
Method, ssl: Private generic functions
Method, ssl-verify: Private generic functions
Method, target: Public generic functions
Method, topic: Public generic functions
Method, user: Public generic functions
Method, user: Public generic functions
Method, user-class: Public generic functions
Method, users: Public generic functions
Method, users: Public generic functions

N
name: Public generic functions
name: Public generic functions
new-nick: Public generic functions
new-nick: Public generic functions
new-topic: Public generic functions
new-topic: Public generic functions
nick: Public generic functions
nick: Public generic functions

P
parse-message: Public ordinary functions
parse-prefix: Public ordinary functions
pass: Public generic functions
pass: Public generic functions
process-message: Public ordinary functions
process-message-loop: Public ordinary functions

R
read-message: Public ordinary functions
real-name: Public generic functions
real-name: Public generic functions
remove-user: Public ordinary functions
rename-user: Public ordinary functions
reply->keyword: Public ordinary functions

S
server-host: Public generic functions
server-host: Public generic functions
server-port: Public generic functions
server-port: Public generic functions
socket-stream: Public generic functions
socket-stream: Public generic functions
ssl: Private generic functions
ssl: Private generic functions
ssl-verify: Private generic functions
ssl-verify: Private generic functions

T
target: Public generic functions
target: Public generic functions
topic: Public generic functions
topic: Public generic functions

U
user: Public generic functions
user: Public generic functions
user: Public generic functions
user-class: Public generic functions
user-class: Public generic functions
users: Public generic functions
users: Public generic functions
users: Public generic functions

V
valid-channel-name-p: Private ordinary functions

Jump to:   %   (   /  
A   C   D   E   F   G   H   I   M   N   P   R   S   T   U   V  

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

A.3 Variables

Jump to:   %   *  
A   C   H   M   N   P   R   S   T   U  
Index Entry  Section

%
%socket: Public classes

*
*reply-codes*: Private special variables

A
activep: Public classes

C
channel: Public classes
channel-class: Public classes
channel-type: Public classes
channels: Public classes
connection: Public classes
connection: Public classes

H
host: Public classes

M
message: Public classes

N
name: Public classes
new-nick: Public classes
new-topic: Public classes
nick: Public classes

P
pass: Public classes

R
real-name: Public classes

S
server-host: Public classes
server-port: Public classes
Slot, %socket: Public classes
Slot, activep: Public classes
Slot, channel: Public classes
Slot, channel-class: Public classes
Slot, channel-type: Public classes
Slot, channels: Public classes
Slot, connection: Public classes
Slot, connection: Public classes
Slot, host: Public classes
Slot, message: Public classes
Slot, name: Public classes
Slot, new-nick: Public classes
Slot, new-topic: Public classes
Slot, nick: Public classes
Slot, pass: Public classes
Slot, real-name: Public classes
Slot, server-host: Public classes
Slot, server-port: Public classes
Slot, socket-stream: Public classes
Slot, ssl: Public classes
Slot, ssl-verify: Public classes
Slot, target: Public classes
Slot, topic: Public classes
Slot, user: Public classes
Slot, user: Public classes
Slot, user-class: Public classes
Slot, users: Public classes
Slot, users: Public classes
socket-stream: Public classes
Special Variable, *reply-codes*: Private special variables
ssl: Public classes
ssl-verify: Public classes

T
target: Public classes
topic: Public classes

U
user: Public classes
user: Public classes
user-class: Public classes
users: Public classes
users: Public classes

Jump to:   %   *  
A   C   H   M   N   P   R   S   T   U  

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

A.4 Data types

Jump to:   B   C   E   F   I   J   K   N   P   Q   R   S   T   U  
Index Entry  Section

B
birch: The birch system
birch: The birch package
birch.asd: The birch/birch․asd file
birch/commands: The birch/commands package
birch/connection: The birch/connection package
birch/ctcp: The birch/ctcp package
birch/events: The birch/events package
birch/init: The birch/init package
birch/parse: The birch/parse package
birch/replies: The birch/replies package

C
channel: Public classes
channel-event: Public classes
channel-type: Public types
Class, channel: Public classes
Class, channel-event: Public classes
Class, connection: Public classes
Class, event: Public classes
Class, join-event: Public classes
Class, kick-event: Public classes
Class, nick-event: Public classes
Class, notice-event: Public classes
Class, part-event: Public classes
Class, privmsg-event: Public classes
Class, quit-event: Public classes
Class, topic-event: Public classes
Class, user: Public classes
commands.lisp: The birch/commands․lisp file
connection: Public classes
connection.lisp: The birch/connection․lisp file
ctcp.lisp: The birch/ctcp․lisp file

E
event: Public classes
events.lisp: The birch/events․lisp file

F
File, birch.asd: The birch/birch․asd file
File, commands.lisp: The birch/commands․lisp file
File, connection.lisp: The birch/connection․lisp file
File, ctcp.lisp: The birch/ctcp․lisp file
File, events.lisp: The birch/events․lisp file
File, init.lisp: The birch/init․lisp file
File, package.lisp: The birch/package․lisp file
File, parse.lisp: The birch/parse․lisp file
File, replies.lisp: The birch/replies․lisp file

I
init.lisp: The birch/init․lisp file

J
join-event: Public classes

K
kick-event: Public classes

N
nick-event: Public classes
notice-event: Public classes

P
Package, birch: The birch package
Package, birch/commands: The birch/commands package
Package, birch/connection: The birch/connection package
Package, birch/ctcp: The birch/ctcp package
Package, birch/events: The birch/events package
Package, birch/init: The birch/init package
Package, birch/parse: The birch/parse package
Package, birch/replies: The birch/replies package
package.lisp: The birch/package․lisp file
parse.lisp: The birch/parse․lisp file
part-event: Public classes
privmsg-event: Public classes

Q
quit-event: Public classes

R
replies.lisp: The birch/replies․lisp file

S
System, birch: The birch system

T
topic-event: Public classes
Type, channel-type: Public types

U
user: Public classes

Jump to:   B   C   E   F   I   J   K   N   P   Q   R   S   T   U