The qbase64 Reference Manual

Table of Contents

The qbase64 Reference Manual

This is the qbase64 Reference Manual, version 0.3.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Mon Dec 02 11:08:53 2019 GMT+0.

1 Introduction

qbase64

qbase64 provides a fast and flexible base64 encoder and decoder for Common Lisp. It provides three interfaces for both encoding and decoding:

• ENCODE-BYTES and DECODE-STRING are the easiest to use. They allow one to encode a byte vector and decode a base64 string in one go.

• ENCODE-STREAM and DECODE-STREAM are gray stream classes that allow one to write and read bytes from underlying character streams.

• ENCODER and DECODER provide the low level interface. The other interfaces are built on top of these.

Table of Contents

• Why qbase64?
• Installation
• Usage
  • Encoding
  • Decoding
  • Advanced
• Limits and Assertions
• Performance
• Additional Features
  • Encoding Schemes
  • Linebreaks
• API Reference
• Reporting Bugs

Why qbase64?

Given that a couple of Lisp libraries already exist for working with base64 - cl-base64 and s-base64 - why might you want to pick qbase64? There are two reasons:

1. Stream-based APIs - neither of the alternatives provide a (gray) stream implementation where you can write bytes to a binary stream that is automatically encoded to an underlying character stream and vice-versa.

2. Performance - qbase64 was written with the objective of being fast while keeping memory consumption independent of the input size. See the Performance section for benchmarks and other details.

Installation

Install using quicklisp:

(ql:quickload :qbase64)

Usage

Encoding

The examples below use ENCODE-BYTES and ENCODE-STREAM.

;;; ENCODE-BYTES
(qbase64:encode-bytes #(1 2 3 4 5 6 7 8))
=> "AQIDBAUGBwg="

;;; ENCODE-STREAM
(with-output-to-string (s)
  (with-open-stream (out (make-instance 'qbase64:encode-stream
                                        :underlying-stream s))
    (write-sequence #(1 2 3 4) out)
    (write-sequence #(5 6 7 8) out)))
=> "AQIDBAUGBwg="

Decoding

The examples below use DECODE-STRING and DECODE-STREAM.

;;; DECODE-STRING
(qbase64:decode-string "AQIDBAUGBwg=")
=> #(1 2 3 4 5 6 7 8)

;;; DECODE-STREAM
(with-input-from-string (s "AQIDBAUGBwg=")
  (with-open-stream (in (make-instance 'qbase64:decode-stream
                                       :underlying-stream s))
    (let ((bytes (make-array 4)))
      (loop
         for position = (read-sequence bytes in)
         do (print (subseq bytes 0 position))
         while (= position (length bytes))))))
; #(1 2 3 4) 
; #(5 6 7 8) 
; #() 

Advanced

Normally you wouldn't need to use ENCODER and DECODER directly, but if you do (say you want more control over memory management), you can refer to the examples below.

In these examples, fixed length sequences are used for both input and output, and any input buffered by the encoder/decoder is first cleared before further input is fed to it. This allows very tight control over how much memory gets used.

Refer to the doc strings for ENCODER, ENCODE, DECODER and DECODE for more details.

Note that running the following examples requires FLEXI-STREAMS.

;;; ENCODER
(flexi-streams:with-input-from-sequence (in #(1 2 3 4 5 6 7 8))
  (let* ((encoder (qbase64:make-encoder))
         (bytes (make-array 4))
         (string (make-string 5))
         (read-bytes t)
         (buffered nil)
         (eof nil))
    (loop
       while (or buffered (not eof))
       for end1 = (when read-bytes (read-sequence bytes in))
       if (and read-bytes (< end1 (length bytes))) do (setf eof t)
       do
         (multiple-value-bind (end2 pending)
             (if read-bytes
                 (qbase64:encode encoder bytes string :end1 end1 :finish eof)
                 (qbase64:encode encoder #() string :finish eof))
           (write-string string nil :end end2)
           (setf buffered pending
                 read-bytes (or (not pending) (zerop end2)))))))
; AQIDBAUGBwg=

;;; DECODER
(with-input-from-string (in "AQIDBAUGBwg=")
  (let* ((decoder (qbase64:make-decoder))
         (string (make-string 4))
         (bytes (make-array 5))
         (read-string t)
         (buffered nil)
         (eof nil))
    (loop
       while (or buffered (not eof))
       for end1 = (when read-string (read-sequence string in))
       if (and read-string (< end1 (length string))) do (setf eof t)
       do
         (multiple-value-bind (end2 pending)
             (if read-string
                 (qbase64:decode decoder string bytes :end1 end1)
                 (qbase64:decode decoder "" bytes))
           (print (subseq bytes 0 end2))
           (setf buffered pending
                 read-string (or (not pending) (zerop end2)))))))
; #(1 2 3)
; #(4 5 6)
; #(7 8)
; #()

Limits and Assertions

The library relies on (UNSIGNED-BYTE 8) and fixnum arithmetic to achieve good performance. Consequently,

• When providing bytes for encoding, ensure that each byte is of type (UNSIGNED-BYTE 8). Although the ARRAY-ELEMENT-TYPE of the byte array can be T, the elements themselves must conform to this restriction.

• Max length of the byte vector that is used as encoding input or decoding output should never exceed +MAX-BYTES-LENGTH+.

• Max length of the string that is used as encoding output or decoding input should never exceed +MAX-STRING-LENGTH+.

Performance

See this page for CPU and memory benchmarks vs other CL libraries.

Encoding and decoding should be very fast under these conditions:

• The byte vector is a SIMPLE-ARRAY of element type (UNSIGNED-BYTE 8).

• The string is a SIMPLE-STRING. Theoretically SIMPLE-BASE-STRING could be even faster.

That said, these are just the optimal conditions. You can safely use any STRING or VECTOR with qbase64 if needed.

Additional Features

Encoding Schemes

Two base64 encoding schemes are supported: original (the default) and URI.

URI encoding scheme is useful when base64 strings are used as GET or POST values in an HTTP request.

The scheme can be set by using the :SCHEME keyword.

(qbase64:encode-bytes #(251 252 253 254 255) :scheme :original)
=> "+/z9/v8="

(qbase64:encode-bytes #(251 252 253 254 255) :scheme :uri)
=> "-_z9_v8="

Linebreaks

The encoded base64 stream can broken into multiple lines using the :LINEBREAK keyword. By default it is 0, which means that no newlines are output. Setting it to a positive integer indicates the column number at which lines should be broken.

(princ (qbase64:encode-bytes #(1 2 3 4 5 6 7 8) :linebreak 4))
; AQID
; BAUG
; Bwg=

During decoding, all whitespace (including newlines) is ignored.

API Reference

At the moment, API reference is available in the form of doc strings for all the exported symbols.

Reporting Bugs

To report a bug in the library, create a Github issue.

2 Systems

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

2.1 qbase64

Author

Chaitanya Gupta <mail@chaitanyagupta.com>

License

BSD-3-Clause

Description

Fast and flexible base64 encoder and decoder

Version

0.3.0

Dependencies

• trivial-gray-streams
• metabang-bind

Source

qbase64.asd (file)

Components

• package.lisp (file)
• utils.lisp (file)
• stream-utils.lisp (file)
• qbase64.lisp (file)

3 Files

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

3.1 Lisp

3.1.1 qbase64.asd

Location

qbase64.asd

Systems

qbase64 (system)

3.1.2 qbase64/package.lisp

Parent

qbase64 (system)

Location

package.lisp

Packages

qbase64

3.1.3 qbase64/utils.lisp

Dependency

package.lisp (file)

Parent

qbase64 (system)

Location

utils.lisp

Internal Definitions

• bytes (function)
• define-constant (macro)
• defun/td (macro)
• least-multiple-upfrom (function)
• make-byte-vector (function)
• parse-body (function)
• positive-fixnum (type)

3.1.4 qbase64/stream-utils.lisp

Dependency

utils.lisp (file)

Parent

qbase64 (system)

Location

stream-utils.lisp

Internal Definitions

• stream-mixin (class)
• stream-open-p (method)
• (setf stream-open-p) (method)

3.1.5 qbase64/qbase64.lisp

Dependency

stream-utils.lisp (file)

Parent

qbase64 (system)

Location

qbase64.lisp

Exported Definitions

• +max-bytes-length+ (constant)
• +max-string-length+ (constant)
• decode (function)
• decode-stream (class)
• decode-string (function)
• decoder (structure)
• encode (function)
• encode-bytes (function)
• encode-stream (class)
• encoder (structure)
• make-decoder (function)
• make-encoder (function)

Internal Definitions

• %decode (function)
• %encode (function)
• %make-decoder (function)
• %make-encoder (function)
• %stream-write-sequence (function)
• +empty-bytes+ (constant)
• +empty-string+ (constant)
• +original-reverse-set+ (constant)
• +original-set+ (constant)
• +pad-char+ (constant)
• +uri-reverse-set+ (constant)
• +uri-set+ (constant)
• copy-decoder (function)
• copy-encoder (function)
• decode-length (function)
• decoder-p (function)
• decoder-pchars (function)
• (setf decoder-pchars) (function)
• decoder-pchars-end (function)
• (setf decoder-pchars-end) (function)
• decoder-scheme (function)
• (setf decoder-scheme) (function)
• encode-length (function)
• encoder-finish-p (function)
• (setf encoder-finish-p) (function)
• encoder-p (function)
• encoder-pbytes (function)
• (setf encoder-pbytes) (function)
• encoder-pbytes-end (function)
• (setf encoder-pbytes-end) (function)
• encoder-scheme (function)
• (setf encoder-scheme) (function)
• fill-pchars (function)
• flush-pending-bytes (function)
• resize-pchars (function)
• reverse-set (function)
• scheme (type)
• whitespace-p (function)
• write-buffer-to-sequence (function)

4 Packages

Packages are listed by definition order.

4.1 qbase64

Source

package.lisp (file)

Use List

• trivial-gray-streams
• common-lisp

Exported Definitions

• +max-bytes-length+ (constant)
• +max-string-length+ (constant)
• decode (function)
• decode-stream (class)
• decode-string (function)
• decoder (structure)
• encode (function)
• encode-bytes (function)
• encode-stream (class)
• encoder (structure)
• make-decoder (function)
• make-encoder (function)

Internal Definitions

• %decode (function)
• %encode (function)
• %make-decoder (function)
• %make-encoder (function)
• %stream-write-sequence (function)
• +empty-bytes+ (constant)
• +empty-string+ (constant)
• +original-reverse-set+ (constant)
• +original-set+ (constant)
• +pad-char+ (constant)
• +uri-reverse-set+ (constant)
• +uri-set+ (constant)
• bytes (function)
• copy-decoder (function)
• copy-encoder (function)
• decode-length (function)
• decoder-p (function)
• decoder-pchars (function)
• (setf decoder-pchars) (function)
• decoder-pchars-end (function)
• (setf decoder-pchars-end) (function)
• decoder-scheme (function)
• (setf decoder-scheme) (function)
• define-constant (macro)
• defun/td (macro)
• encode-length (function)
• encoder-finish-p (function)
• (setf encoder-finish-p) (function)
• encoder-p (function)
• encoder-pbytes (function)
• (setf encoder-pbytes) (function)
• encoder-pbytes-end (function)
• (setf encoder-pbytes-end) (function)
• encoder-scheme (function)
• (setf encoder-scheme) (function)
• fill-pchars (function)
• flush-pending-bytes (function)
• least-multiple-upfrom (function)
• make-byte-vector (function)
• parse-body (function)
• positive-fixnum (type)
• resize-pchars (function)
• reverse-set (function)
• scheme (type)
• stream-mixin (class)
• stream-open-p (generic function)
• stream-open-p (method)
• (setf stream-open-p) (method)
• (setf stream-open-p) (generic function)
• whitespace-p (function)
• write-buffer-to-sequence (function)

5 Definitions

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

5.1 Exported definitions

5.1.1 Constants

Constant: +max-bytes-length+

Max length of the byte array that is used as encoding input or decoding output

Package

qbase64

Source

qbase64.lisp (file)

Constant: +max-string-length+

Max length of the string that is used as encoding output or decoding input

Package

qbase64

Source

qbase64.lisp (file)

5.1.2 Functions

Function: decode DECODER STRING BYTES &key START1 END1 START2 END2

Decodes the given STRING and writes the resultant bytes to BYTES.

DECODER: The decoder

STRING: The string to decode.

BYTES: This is where the resultant bytes are written into. Should be a single-dimentional array of (UNSIGNED-BYTE 8) elements.

START1, END1: Bounds for STRING

START2, END2: Bounds for BYTES

Whitespace in string is ignored. It is not necessary that the entire STRING is decoded in one go. For example,

* There may not be enough space left in BYTES,

* or the length of the string (minus whitespace chars) may not be a multiple of 4 (base64 decoding works on groups of four characters at at time).

In these cases, DECODE will decode as much of the string as it can and write the resultant bytes into BYTES. The remaining string is copied to an internal buffer by the decoder and used the next time DECODE is called. Also, the second return value (called PENDINGP, see below) is set to true.

DECODE can be given an empty STRING in which case the buffered string is decoded as much as possible.

Returns POSITION, PENDINGP.

POSITION: First index of BYTES that wasn’t updated

PENDINGP: True if not all of the STRING was decoded

Package

qbase64

Source

qbase64.lisp (file)

Function: decode-string STRING &key SCHEME

Decodes base64 chars in STRING and returns an array of (UNSIGNED-BYTE 8) elements.

STRING: The string to decode.

SCHEME: The base64 encoding scheme to use. Must be :ORIGINAL (default) or :URI.

Package

qbase64

Source

qbase64.lisp (file)

Function: encode ENCODER BYTES STRING &key START1 END1 START2 END2 FINISH

Encodes given BYTES and writes the resultant chars to STRING.

ENCODER: The encoder

BYTES: Should be a single-dimentional array of (UNSIGNED-BYTE 8) elements.

STRING: The encoded characters are written into this string.

START1, END1: Bounds for BYTES

START2, END2: Bounds for STRING

FINISH: Padding characters are output if required, and no new bytes can be accepted until all the pending bytes are written out.

It is not necessary that all of BYTES are encoded in one go. For example,

* There may not be enough space left in STRING

* FINISH is not true and the cumulative length of all the bytes given till now is not a multiple of 3 (base64 encoding works on groups of three bytes).

In these cases, as much as possible BYTES are encoded and the resultant chars written into STRING, the remaining bytes are copied to an internal buffer by the encoder and used the next time ENCODE is called. Also, the second value returned (called PENDINGP, see below) is set to true.

If FINISH is true but cumulative length of all the BYTES is not a multiple of 3, padding characters are written into STRING.

ENCODE can be given an empty BYTES array in which case the internal buffer is encoded as much as possible.

Returns POSITION, PENDINGP.

POSITION: First index of STRING that wasn’t updated

PENDINGP: True if not all BYTES were encoded

Package

qbase64

Source

qbase64.lisp (file)

Function: encode-bytes BYTES &key SCHEME LINEBREAK

Encode BYTES to base64 and return the string.

BYTES: Should be a single-dimentional array of (UNSIGNED-BYTE 8) elements.

SCHEME: The base64 encoding scheme to use. Must
be :ORIGINAL (default) or :URI.

LINEBREAK: If 0 (the default), no linebreaks are written. Otherwise its value must be the max number of characters per line.

Package

qbase64

Source

qbase64.lisp (file)

Function: make-decoder &key SCHEME

Creates a DECODER.

SCHEME: The base64 encoding scheme to use. Can be :ORIGINAL or :URI

Package

qbase64

Source

qbase64.lisp (file)

Function: make-encoder &key SCHEME

Creates an ENCODER.

SCHEME: The base64 encoding scheme to use. Can be :ORIGINAL or :URI

Package

qbase64

Source

qbase64.lisp (file)

5.1.3 Structures

Structure: decoder ()

Use a DECODER to decode base64 characters to bytes. Use MAKE-DECODER to create a decoder, then decode base64 chars using DECODE.

Package

qbase64

Source

qbase64.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots

Slot: scheme

Readers

decoder-scheme (function)

Writers

(setf decoder-scheme) (function)

Slot: pchars

Type

simple-base-string

Initform

(make-string 0 :element-type (quote base-char))

Readers

decoder-pchars (function)

Writers

(setf decoder-pchars) (function)

Slot: pchars-end

Initform

0

Readers

decoder-pchars-end (function)

Writers

(setf decoder-pchars-end) (function)

Structure: encoder ()

Use an ENCODER to encode bytes to string. Create an encoder using MAKE-ENCODER, then start encoding bytes using ENCODE.

Package

qbase64

Source

qbase64.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots

Slot: scheme

Type

qbase64::scheme

Initform

:original

Readers

encoder-scheme (function)

Writers

(setf encoder-scheme) (function)

Slot: pbytes

Type

(simple-array (unsigned-byte 8))

Initform

qbase64::+empty-bytes+

Readers

encoder-pbytes (function)

Writers

(setf encoder-pbytes) (function)

Slot: pbytes-end

Type

qbase64::positive-fixnum

Initform

0

Readers

encoder-pbytes-end (function)

Writers

(setf encoder-pbytes-end) (function)

Slot: finish-p

Readers

encoder-finish-p (function)

Writers

(setf encoder-finish-p) (function)

5.1.4 Classes

Class: decode-stream ()

A binary input stream that converts base64 chars from an underlying stream to bytes.

Create a DECODE-STREAM using MAKE-INSTANCE. The following initialization keywords are provided:

UNDERLYING-STREAM: The underlying character input stream from which base64 chars are read. Must be given.

SCHEME: The base64 encoding scheme to use. Must
be :ORIGINAL (default) or :URI.

Note that DECODE-STREAM does not close the underlying stream when CLOSE is invoked.

Package

qbase64

Source

qbase64.lisp (file)

Direct superclasses

• trivial-gray-stream-mixin (class)
• fundamental-binary-input-stream (class)
• stream-mixin (class)

Direct methods

• stream-read-byte (method)
• stream-read-sequence (method)
• stream-element-type (method)
• input-stream-p (method)
• initialize-instance (method)

Direct slots

Slot: underlying-stream

Initargs

:underlying-stream

Slot: decoder

Slot: string

Initform

qbase64::+empty-string+

Slot: buffer

Initform

(qbase64::make-byte-vector 3)

Slot: buffer-end

Initform

0

Slot: single-byte-vector

Initform

(qbase64::make-byte-vector 1)

Class: encode-stream ()

A binary output stream that converts bytes to base64 characters and writes them to an underlyihng character output stream.

Create an ENCODE-STREAM using MAKE-INSTANCE. The following initialization keywords are provided:

UNDERLYING-STREAM: The underlying character output stream to which base64 characters are written. Must be given.

SCHEME: The base64 encoding scheme to use. Must
be :ORIGINAL (default) or :URI.

LINEBREAK: If 0 (the default), no linebreaks are written. Otherwise its value must be the max number of characters per line.

Note that ENCODE-STREAM does not close the underlying stream when CLOSE is invoked.

Package

qbase64

Source

qbase64.lisp (file)

Direct superclasses

• trivial-gray-stream-mixin (class)
• fundamental-binary-output-stream (class)
• stream-mixin (class)

Direct methods

• close (method)
• stream-finish-output (method)
• stream-force-output (method)
• stream-write-byte (method)
• stream-write-sequence (method)
• stream-element-type (method)
• output-stream-p (method)
• initialize-instance (method)

Direct slots

Slot: underlying-stream

Initargs

:underlying-stream

Slot: encoder

Slot: string

Initform

qbase64::+empty-string+

Slot: single-byte-vector

Initform

(qbase64::make-byte-vector 1)

Slot: linebreak

Initargs

:linebreak

Initform

0

Slot: column

Initform

0

5.2 Internal definitions

5.2.1 Constants

Constant: +empty-bytes+

Package

qbase64

Source

qbase64.lisp (file)

Constant: +empty-string+

Package

qbase64

Source

qbase64.lisp (file)

Constant: +original-reverse-set+

Package

qbase64

Source

qbase64.lisp (file)

Constant: +original-set+

Package

qbase64

Source

qbase64.lisp (file)

Constant: +pad-char+

Package

qbase64

Source

qbase64.lisp (file)

Constant: +uri-reverse-set+

Package

qbase64

Source

qbase64.lisp (file)

Constant: +uri-set+

Package

qbase64

Source

qbase64.lisp (file)

5.2.2 Macros

Macro: define-constant NAME VALUE &optional DOC

Package

qbase64

Source

utils.lisp (file)

Macro: defun/td NAME LAMBDA-LIST TYPE-DECLS-LIST &body BODY

Package

qbase64

Source

utils.lisp (file)

5.2.3 Functions

Function: %decode STRING BYTES &key SCHEME START1 END1 START2 END2

Package

qbase64

Source

qbase64.lisp (file)

Function: %encode BYTES STRING &key SCHEME ENCODE-TRAILING-BYTES START1 END1 START2 END2

Package

qbase64

Source

qbase64.lisp (file)

Function: %make-decoder &key (SCHEME SCHEME) (PCHARS PCHARS) (PCHARS-END PCHARS-END)

Package

qbase64

Source

qbase64.lisp (file)

Function: %make-encoder &key (SCHEME SCHEME) (PBYTES PBYTES) (PBYTES-END PBYTES-END) (FINISH-P FINISH-P)

Package

qbase64

Source

qbase64.lisp (file)

Function: %stream-write-sequence STREAM SEQUENCE START END FINISH

Package

qbase64

Source

qbase64.lisp (file)

Function: bytes &rest CONTENTS

Package

qbase64

Source

utils.lisp (file)

Function: copy-decoder INSTANCE

Package

qbase64

Source

qbase64.lisp (file)

Function: copy-encoder INSTANCE

Package

qbase64

Source

qbase64.lisp (file)

Function: decode-length LENGTH

Package

qbase64

Source

qbase64.lisp (file)

Function: decoder-p OBJECT

Package

qbase64

Source

qbase64.lisp (file)

Function: decoder-pchars INSTANCE

Function: (setf decoder-pchars) VALUE INSTANCE

Package

qbase64

Source

qbase64.lisp (file)

Function: decoder-pchars-end INSTANCE

Function: (setf decoder-pchars-end) VALUE INSTANCE

Package

qbase64

Source

qbase64.lisp (file)

Function: decoder-scheme INSTANCE

Function: (setf decoder-scheme) VALUE INSTANCE

Package

qbase64

Source

qbase64.lisp (file)

Function: encode-length LENGTH ENCODE-TRAILING-BYTES

Package

qbase64

Source

qbase64.lisp (file)

Function: encoder-finish-p INSTANCE

Function: (setf encoder-finish-p) VALUE INSTANCE

Package

qbase64

Source

qbase64.lisp (file)

Function: encoder-p OBJECT

Package

qbase64

Source

qbase64.lisp (file)

Function: encoder-pbytes INSTANCE

Function: (setf encoder-pbytes) VALUE INSTANCE

Package

qbase64

Source

qbase64.lisp (file)

Function: encoder-pbytes-end INSTANCE

Function: (setf encoder-pbytes-end) VALUE INSTANCE

Package

qbase64

Source

qbase64.lisp (file)

Function: encoder-scheme INSTANCE

Function: (setf encoder-scheme) VALUE INSTANCE

Package

qbase64

Source

qbase64.lisp (file)

Function: fill-pchars DECODER STRING &key START END

Package

qbase64

Source

qbase64.lisp (file)

Function: flush-pending-bytes STREAM

Package

qbase64

Source

qbase64.lisp (file)

Function: least-multiple-upfrom MULTIPLE-OF UPFROM

Package

qbase64

Source

utils.lisp (file)

Function: make-byte-vector SIZE

Package

qbase64

Source

utils.lisp (file)

Function: parse-body BODY &key DOCUMENTATION WHOLE

Parses BODY into (values remaining-forms declarations doc-string). Documentation strings are recognized only if DOCUMENTATION is true. Syntax errors in body are signalled and WHOLE is used in the signal arguments when given.

Package

qbase64

Source

utils.lisp (file)

Function: resize-pchars PCHARS PCHARS-END NEW-LENGTH

Package

qbase64

Source

qbase64.lisp (file)

Function: reverse-set SET

Package

qbase64

Source

qbase64.lisp (file)

Function: whitespace-p C

Returns T for a whitespace character.

Package

qbase64

Source

qbase64.lisp (file)

Function: write-buffer-to-sequence STREAM SEQUENCE START END

Package

qbase64

Source

qbase64.lisp (file)

5.2.4 Generic functions

Generic Function: stream-open-p OBJECT

Generic Function: (setf stream-open-p) NEW-VALUE OBJECT

Package

qbase64

Methods

Method: stream-open-p (STREAM-MIXIN stream-mixin)

automatically generated reader method

Source

stream-utils.lisp (file)

Method: (setf stream-open-p) NEW-VALUE (STREAM-MIXIN stream-mixin)

automatically generated writer method

Source

stream-utils.lisp (file)

5.2.5 Classes

Class: stream-mixin ()

Package

qbase64

Source

stream-utils.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

• encode-stream (class)
• decode-stream (class)

Direct methods

• output-stream-p (method)
• input-stream-p (method)
• close (method)
• open-stream-p (method)
• stream-open-p (method)
• stream-open-p (method)

Direct slots

Slot: openp

Initform

t

Readers

stream-open-p (generic function)

Writers

(setf stream-open-p) (generic function)

5.2.6 Types

Type: positive-fixnum ()

Package

qbase64

Source

utils.lisp (file)

Type: scheme ()

Package

qbase64

Source

qbase64.lisp (file)

Appendix A Indexes

A.1 Concepts

A.2 Functions

A.3 Variables

A.4 Data types