The depot Reference Manual

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

The depot Reference Manual

This is the depot Reference Manual, version 1.0.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Thu Sep 15 04:37:18 2022 GMT+0.

Table of Contents


1 Introduction

## About This
This is a system presenting a protocol for "file systems" -- things that present a collection of "files," which are things that have several attributes, and a central data payload. Most notably this includes the OS filesystem, but can also be used to address other filesystem-like things like archives, object stores, etc. in the same manner.

## How To
For the purposes of this introduction we will assume that the package ``org.shirakumo.depot`` has the local nickname ``depot``.

While depot interactions depend directly on the storage backend used, most operating systems have a hierarchical file system that we can access. We will concentrate on that backend in this tutorial.

First, we can access the file system through the ``*os-depot*`` variable, which gives us a base ``depot``. We can then ask it for what entries it has:

:: common lisp
(depot:list-entries depot:*os-depot*)
; => (#)
::

Not much going on there, but the ``host`` is another ``depot``, so we can do the same again:

:: common lisp
(depot:list-entries (first *))
; => (#)
::

Aha! Now we get a ``device`` object, which on this system seems to represent the root directory. Let's ask it for entries once again:

:: common lisp
(depot:list-entries (first *))
; => (# ...)
::

This should give a list of ``directory``s present on the device's root, and possibly some ``file``s as well. Before we go any further though, traversing a deeply hierarchical system like this is kind of tedious. We can instead use ``entry*`` which traverses multiple levels at once, or even better for pathnames we can use ``from-pathname``.

:: common lisp
(depot:from-pathname (user-homedir-pathname))
; => #
::

Now here we can do something a bit more interesting aside from listing its entries. We can create a new one:

:: common lisp
(depot:make-entry * :name "test")
; => #
::

The attributes you can pass when creating an entry depend on the backend used. For the filesystem, we can pass the name and the type. You can also query these attributes later using ``attributes`` for the full list, or ``attribute`` for a single attribute. Some attributes can also be changed by setting them.

With this new file entry, we can now write some data to it:

:: common lisp
(depot:with-open (transaction * :output 'character)
  (depot:write-to transaction "Hello!"))
; => "Hello!"
::

This should look very similar to standard ``with-open-file`` stuff, but underneath lie more powerful semantics. The ``transaction`` guarantees atomicity of the change, meaning multiple writers cannot run over each other, and the change cannot be seen until the transaction has been ``commit``ted. The commit here happens automatically when exiting ``with-open`` normally.

You can also manually control transactions via ``open-entry``, ``read-from``, ``write-to``, ``commit``, and ``abort``.

Now that we have written a new file, we can also read it back again:

:: common lisp
(depot:read-from ** 'character)
; => "Hello!"
::

Excellent. To conclude this demonstration, let's clean up after ourselves by deleting the entry again:

:: common lisp
(depot:delete-entry ***)
::

Once deleted, an entry is invalidated and operating on it is no longer allowed.

Finally, some entries in a depot may themselves represent a depot in another backend. For instance, a zip archive stored in a file may itself be a depot. To 'realise' this fact, you can call ``realize-entry`` on the entry. The second argument can be ``T`` to query all backends, or a specific ``realizer`` instance of a backend to force conversion of a particular kind. If successful, it should return a new ``depot`` or ``entry`` instance that you can use in the context of the new backend.

There's a few more functions to query entries within a depot more efficiently, and get information out of an entry. You can find them linked in the ``depot``  and ``entry`` documentation sections.

## Available Backends
The following storage backends are supported:

- pathname
- zip (depot-zip)
- in-memory (depot-in-memory)
- virtual (depot-virtual)

## Writing New Backends
If you have a new storage backend that you would like to support with the depot protocol, all you need to do is create subclasses of ``depot``, ``entry``, and ``transaction``, and implement methods for the generic functions mentioned in their documentation sections.

If your backend covers something that can be embedded in another depot, you'll also want to use ``define-realizer`` to define appropriate conversion functions.


2 Systems

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


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

2.1 depot

Protocol for transparent collections of files.

Maintainer

Nicolas Hafner <shinmera@tymoon.eu>

Author

Nicolas Hafner <shinmera@tymoon.eu>

Home Page

https://shinmera.github.io/depot

Source Control

(GIT https://github.com/Shinmera/depot.git)

Bug Tracker

https://github.com/Shinmera/depot/issues

License

zlib

Version

1.0.0

Dependencies
  • documentation-utils (system).
  • trivial-features (system).
  • trivial-gray-streams (system).
Source

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

Source

depot.asd.

Parent Component

depot (system).

ASDF Systems

depot.


3.1.2 depot/package.lisp

Source

depot.asd.

Parent Component

depot (system).

Packages

org.shirakumo.depot.


3.1.3 depot/conditions.lisp

Dependency

package.lisp (file).

Source

depot.asd.

Parent Component

depot (system).

Public Interface
Internals

3.1.4 depot/protocol.lisp

Dependency

conditions.lisp (file).

Source

depot.asd.

Parent Component

depot (system).

Public Interface
Internals

3.1.5 depot/pathname.lisp

Dependency

protocol.lisp (file).

Source

depot.asd.

Parent Component

depot (system).

Public Interface
Internals

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

3.1.6 depot/documentation.lisp

Dependency

pathname.lisp (file).

Source

depot.asd.

Parent Component

depot (system).


4 Packages

Packages are listed by definition order.


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

4.1 org.shirakumo.depot

Source

package.lisp.

Use List

common-lisp.

Public Interface
Internals

5 Definitions

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


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

5.1 Public Interface


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

5.1.1 Special variables

Special Variable: *os-depot*

Contains the base depot for the operating system according to the implementation.

See OS-DEPOT

Package

org.shirakumo.depot.

Source

pathname.lisp.


5.1.2 Macros

Macro: define-realizer (name &body dispatchers)

Define a new realizer.

This does the following:

If no class named NAME exists yet, it is defined as a subclass of REALIZER. For each of the DISPATCHERS in the body it defines a method on REALIZE-ENTRY, with the structure of each dispatcher being as follows:

((var class) . body)

CLASS naming a class that the entry must be a subclass of, and VAR being the variable to which the entry is bound. BODY being the forms that are executed when a matching entry is being realised.

See REALIZER
See REGISTER-REALIZER
See REMOVE-REALIZER
See REALIZE-ENTRY

Package

org.shirakumo.depot.

Source

protocol.lisp.

Macro: with-depot ((depot init &key commit) &body body)
Package

org.shirakumo.depot.

Source

protocol.lisp.

Macro: with-open ((transaction entry direction element-type &rest args) &body body)

Macro to conveniently handle a transaction.

Will call OPEN-ENTRY on the passed arguments, bind the resulting transaction to TRANSACTION, and evaluate the BODY. During execution of the BODY, an ABORT restart is established. This restart will invoke ABORT on the transaction object and exit the body.

If the body is executed to completion, the transaction is COMMITTed. If the body should exit abnormally, the transaction is ABORTed.

See OPEN-ENTRY
See ABORT
See COMMIT
See TRANSACTION

Package

org.shirakumo.depot.

Source

protocol.lisp.


5.1.3 Ordinary functions

Function: entry* (depot &rest ids)

Resolves a chain of depot entries.

This is as if calling ENTRY on each passed ID and replacing the depot with the result. The last depot is returned.

This is useful for hierarchical depots.

See ENTRY

Package

org.shirakumo.depot.

Source

protocol.lisp.

Function: from-pathname (pathname &key create-directories)

Returns an entry corresponding to the given pathname.

This may signal an error of type NO-SUCH-ENTRY if the entry does not exist.

If CREATE-DIRECTORIES is true, inexistent entries along the pathname’s directories will be created. If it is :PRETEND (the default), then the directories are not actually created on the filesystem, but instead are virtual.

Returns a FILE or DIRECTORY.

See TO-PATHNAME
See FILE
See DIRECTORY

Package

org.shirakumo.depot.

Source

pathname.lisp.

Function: register-realizer (realizer)

Register a realizer.

You can pass a symbol naming the class of a realizer, a realizer subclass, or a realizer instance.

See REALIZER
See REMOVE-REALIZER
See DEFINE-REALIZER

Package

org.shirakumo.depot.

Source

protocol.lisp.

Function: remove-realizer (realizer)

Deregisters the realizer.

You can pass a symbol naming the class of a realizer, a realizer subclass, or a realizer instance.

See REALIZER
See REGISTER-REALIZER
See DEFINE-REALIZER

Package

org.shirakumo.depot.

Source

protocol.lisp.


5.1.4 Generic functions

Generic Function: abort (transaction &key)

Aborts the transaction and rolls back any changes it may have made.

The transaction is closed and any changes it may have made will be discarded and thus will not be visible to READ transactions (present or future), or other external processes interacting with the same entry.

It is thus as if the transaction had never been opened in the first place.

See OPEN-ENTRY
See TRANSACTION

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: abort ((transaction file-write-transaction) &key)
Source

pathname.lisp.

Method: abort ((transaction stream-transaction) &key)
Generic Function: attribute (name entry)

Accesses a single attribute of the entry.

Which attributes are available depend on the depot/entry used. The only attribute that is required is the :ID attribute.

If the requested attribute does not exist, an error of type NO-SUCH-ATTRIBUTE is signalled.

When setting this place, If the attribute cannot be changed, an error of type PERMISSION-DENIED may be signalled.

See ENTRY
See ATTRIBUTES

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: attribute ((name (eql :author)) (entry file))
Source

pathname.lisp.

Method: attribute ((name (eql :write-date)) (entry file))
Source

pathname.lisp.

Method: attribute ((name (eql :type)) (entry file))
Source

pathname.lisp.

Method: attribute ((name (eql :name)) (entry file))
Source

pathname.lisp.

Method: attribute ((name (eql :author)) (entry directory))
Source

pathname.lisp.

Method: attribute (name (entry entry))
Generic Function: (setf attribute) (name entry)
Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: (setf attribute) (name (entry entry))
Generic Function: attributes (entry)

Accesses a plist of attributes of the entry.

Which attributes are given depends on the depot/entry used. The only attribute that is required is the :ID attribute.

When setting this place, only the attributes in the provided plist should be changed. Attributes are not removed using this
method. Attributes other than the ones provided in the set plist may change as well, however. Some attributes may also not be changed. If an attribute cannot be changed, an error of type PERMISSION-DENIED may be signalled.

See ENTRY
See ATTRIBUTE

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: attributes ((entry file))
Source

pathname.lisp.

Method: attributes ((entry directory))
Source

pathname.lisp.

Method: attributes ((depot device))
Source

pathname.lisp.

Method: attributes ((depot host))
Source

pathname.lisp.

Method: attributes ((entry entry))
Reader Method: attributes ((condition entry-already-exists))
Source

conditions.lisp.

Target Slot

attributes.

Generic Function: (setf attributes) (entry)
Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: (setf attributes) ((entry entry))
Generic Function: commit (transaction &key)

Commits the transaction and completes any pending operations.

If the underlying entry was created new, but in the meantime the same entry was already created successfully, an error of type ENTRY-ALREADY-EXISTS may be signalled.

If the underlying entry was deleted before the commit, an error of type ENTRY-DOES-NOT-EXIST may be signalled.

If the underlying depot is full and cannot support the amount of data to be committed, an error of type DEPOT-FULL may be signalled.

If the operating user lacks the permissions to complete the operation, an error of type PERMISSION-DENIED may be signalled.

If another write was committed after this transaction was created, but before this call to commit occurred, an error of type WRITE-CONFLICT may be signalled for :OUTPUT transactions, or READ-INVALIDATED for :INPUT transactions.

If the commit completes successfully, the transaction is closed and the changes must become visible to new READ transactions, as well as to other external processes interacting with the same entry.

See OPEN-ENTRY
See TRANSACTION

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: commit ((transaction file-read-transaction) &key)
Source

pathname.lisp.

Method: commit ((transaction file-write-transaction) &key)
Source

pathname.lisp.

Method: commit ((transaction stream-transaction) &key)
Method: commit ((entry entry) &key)
Method: commit ((depot depot) &key)
Generic Function: delete-entry (entry)

Deletes the entry from its depot.

If the depot does not support deleting an entry, an error of type UNSUPPORTED-OPERATION is signalled.

If deleting the entry would violate security restrictions, an error of type PERMISSION-DENIED is signalled.

If the entry does not exist (and thus cannot be deleted), an error of type ENTRY-DOES-NOT-EXIST is signalled.

After an entry has been deleted, operating on it in any way leads to undefined behaviour.

See ENTRY

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: delete-entry ((entry file))
Source

pathname.lisp.

Method: delete-entry ((entry entry))
Generic Function: depot (entry)

Returns the depot the entry is a part of.

See ENTRY
See DEPOT

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: depot ((depot device))
Source

pathname.lisp.

Method: depot ((depot host))
Source

pathname.lisp.

Reader Method: depot ((file file))

automatically generated reader method

Source

pathname.lisp.

Target Slot

depot.

Reader Method: depot ((directory directory))

automatically generated reader method

Source

pathname.lisp.

Target Slot

depot.

Generic Reader: element-type (transaction)
Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Reader Method: element-type ((transaction transaction))

automatically generated reader method

Target Slot

element-type.

Generic Function: ensure-depot (thing)

Attempts to convert the given object to a depot.

If this conversion should not be possible, an error of type NOT-A-DEPOT is signalled.

If a DEPOT is passed, the depot is returned. If an ENTRY is passed, the entry’s originating DEPOT is returned.

See ENTRY
See DEPOT

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: ensure-depot ((pathname pathname))
Source

pathname.lisp.

Method: ensure-depot ((entry entry))
Method: ensure-depot ((depot depot))
Generic Function: ensure-entry (id depot &rest attributes)
Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: ensure-entry (id (depot depot) &rest attributes)
Generic Function: entry (id depot)

Returns the entry with the given ID from the depot.

If no such entry exists in the depot, a NO-SUCH-ENTRY error is signalled.

See ENTRY
See DEPOT

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: entry (id (depot directory))
Source

pathname.lisp.

Method: entry (id (depot depot))
Generic Function: entry-exists-p (id depot)

Returns true if an entry with the given ID exists in the depot.

See DEPOT

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: entry-exists-p (id (depot directory))
Source

pathname.lisp.

Method: entry-exists-p (id (depot depot))
Generic Function: entry-matches-p (entry attribute value)

Returns true if the entry matches the specified attribute query.

The available attributes are dependent on the entry and depot used.

If the requested attribute does not exist, an error of type NO-SUCH-ATTRIBUTE may be signalled.

See ENTRY

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: entry-matches-p ((entry entry) attribute value)
Generic Function: id (entry)

Returns the ID of the entry.

The ID uniquely identifies the entry within the depot.

See ENTRY

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: id ((depot device))
Source

pathname.lisp.

Method: id ((depot host))
Source

pathname.lisp.

Method: id ((entry file))
Source

pathname.lisp.

Method: id ((entry directory))
Source

pathname.lisp.

Method: id ((entry entry))
Reader Method: id ((condition no-such-entry))
Source

conditions.lisp.

Target Slot

id.

Generic Function: index (transaction)

Accesses the index at which in the backing storage read or write operations are performed.

If the TRANSACTION was obtained through OPEN-ENTRY with the DIRECTION
set to :OUTPUT, and the index is set to an index higher than the
current index, the consequences are undefined.

See TRANSACTION

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: index ((stream transaction-stream))
Method: index ((transaction stream-transaction))
Generic Function: (setf index) (transaction)
Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: (setf index) ((transaction stream-transaction))
Generic Function: list-entries (depot)

Returns a fresh list of all entries is the depot.

See ENTRY
See DEPOT

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: list-entries ((depot host))
Source

pathname.lisp.

Method: list-entries ((depot os-depot))
Source

pathname.lisp.

Method: list-entries ((depot directory))
Source

pathname.lisp.

Method: list-entries ((depot depot))
Generic Function: make-entry (depot &key name type id)

Creates a new entry in the depot.

If the depot does not support creating an entry, an error of type UNSUPPORTED-OPERATION is signalled.

If the depot is full and no further entries can be created due to storage constraints, an error of type DEPOT-FULL is signalled.

If creating a new entry with the requested attributes would overwrite an existing entry, an error of type ENTRY-ALREADY-EXISTS is signalled.

If creating the requested entry would violate security restrictions, an error of type PERMISSION-DENIED is signalled.

The attributes that can be passed as keyword arguments are entirely dependent on the depot.

Depending on the depot, calling MAKE-ENTRY may not persist the entry yet, and may only do so once the entry has been written to. As such, an entry created with this function may not immediately be returned by LIST-ENTRIES, QUERY-ENTRIES, and so forth.

See DEPOT
See UNSUPPORTED-OPERATION
See DEPOT-FULL
See ENTRY-ALREADY-EXISTS
See PERMISSION-DENIED

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: make-entry ((depot directory) &key name type id)
Source

pathname.lisp.

Method: make-entry ((depot depot) &key)
Generic Reader: name (condition)

Returns the name of the attribute.

See NO-SUCH-ATTRIBUTE

Package

org.shirakumo.depot.

Methods
Reader Method: name ((condition no-such-attribute))
Source

conditions.lisp.

Target Slot

name.

Generic Reader: object (condition)

Returns the object that the condition relates to.

See DEPOT-CONDITION

Package

org.shirakumo.depot.

Methods
Reader Method: object ((condition depot-condition))
Source

conditions.lisp.

Target Slot

object.

Generic Function: open-entry (entry direction element-type &key external-format)

Open the entry for a read or write transaction.

Returns a live TRANSACTION instance.

DIRECTION must be either :INPUT or :OUTPUT.
ELEMENT-TYPE must be a valid type that the entry supports. The set of supported element types must in the very least include (UNSIGNED-BYTE 8) and CHARACTER.

Depending on the entry type, additional arguments may be accepted that designate transaction properties.

You MUST complete the transaction by use of COMMIT or ABORT at some point, as resources may be allocated in the back that could be exhausted if staying live for too long.

A transaction object may be invalidated by an intermittent write operation to the same entry either through the same process, or through an external mechanism of some kind.

Any changes made to an entry by either WRITE-TO, or by external processes, must not be visible until the transaction has been successfully COMMITTed.

If a transaction is ABORTed, any changes made via WRITE-TO must be discarded as if they had never happened.

See WITH-OPEN
See TRANSACTION
See ENTRY
See COMMIT
See ABORT
See WRITE-TO
See READ-FROM

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: open-entry ((file file) (direction (eql :input)) element-type &key external-format)
Source

pathname.lisp.

Method: open-entry ((file file) (direction (eql :output)) element-type &key external-format)
Source

pathname.lisp.

Method: open-entry ((entry entry) direction element-type &key)
Generic Reader: operation (condition)

Returns the name of the operation that failed.

See UNSUPPORTED-OPERATION

Package

org.shirakumo.depot.

Methods
Reader Method: operation ((condition unsupported-operation))
Source

conditions.lisp.

Target Slot

operation.

Generic Function: query-entries (depot &key host name type version id &allow-other-keys)

Returns a list of entries in the depot that match the queried attributes.

The only required attribute that a depot must be able to query is ID. Other attributes are dependent on the depot and possibly entry being queried.

The order of returned entries is not required to be stable.

See ENTRY
See DEPOT

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: query-entries ((depot os-depot) &key host)
Source

pathname.lisp.

Method: query-entries ((depot directory) &key name type version id)
Source

pathname.lisp.

Method: query-entries ((depot depot) &rest args &key &allow-other-keys)
Generic Function: query-entry (depot &key id device &allow-other-keys)

Returns the matching entry in the depot.

If no matching entry is found, NIL is returned. If multiple entries match, any one of them may be returned.

See QUERY-ENTRIES
See ENTRY
See DEPOT

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: query-entry ((depot device) &key id)
Source

pathname.lisp.

Method: query-entry ((depot host) &key device)
Source

pathname.lisp.

Method: query-entry ((depot depot) &rest args &key &allow-other-keys)
Generic Function: read-from (transaction sequence &key start end block-size &allow-other-keys)

Read a sequence from a transaction.

TRANSACTION must be an object obtained through OPEN-ENTRY with the DIRECTION set to :INPUT, and may not have been aborted, committed, or invalidated.

SEQUENCE must be a lisp sequence type. START and END may be indices into this sequence designating a subsequence to write.

The sequence is filled starting from the current INDEX of the transaction until either the end of the designated sequence is reached, or the end of the transaction is reached.

Returns the index of the last element in the sequence that was modified.

If another write was committed after the transaction was created, but before this call an error of type READ-INVALIDATED may be signalled.

You may also call this on an ENTRY directly, in which case it will construct a transaction, read the sequence, and immediately attempt to COMMIT. In this case you may also pass either ’BYTE or ’CHARACTER as arguments to the second argument, in which case a vector will be constructed for you and returned instead of the last modified index. The vector will have element type of (UNSIGNED-BYTE 8) or CHARACTER, respectively.

See OPEN-ENTRY
See TRANSACTION

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: read-from ((transaction stream-transaction) (sequence sequence) &key start end)
Method: read-from ((tx transaction) (target (eql character)) &key start end block-size)
Method: read-from ((tx transaction) (target (eql byte)) &key start end)
Method: read-from ((entry entry) (target (eql character)) &rest args &key &allow-other-keys)
Method: read-from ((entry entry) (target (eql byte)) &rest args &key &allow-other-keys)
Method: read-from ((entry entry) (target vector) &rest args &key &allow-other-keys)
Generic Function: realize-entry (entry realizer)

Attempts to turn the entry into another entry or depot of another backend.

This allows you to access the contents of a depot that’s encoded within another depot.

You may either pass a realizer instance, or T. If T is passed, each of the known realizers is tried in turn until one that passes is found, whose result is returned. If no realizer accepts the entry, NIL is returned. If a realizer instance is passed directly and it fails at realizing the entry, an error is signalled.

When successful the result may be an ENTRY or a DEPOT.

See ENTRY
See REALIZER

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: realize-entry ((pathname pathname) realizer)
Source

pathname.lisp.

Method: realize-entry ((entry entry) (realizer symbol))
Method: realize-entry ((entry entry) (all (eql t)))
Generic Function: size (transaction)

Returns the size (in elements) of the backing storage the transaction represents.

If the TRANSACTION was not obtained through OPEN-ENTRY with the
DIRECTION set to :INPUT, the consequences of this function are
implementation defined.

See TRANSACTION

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: size ((stream transaction-stream))
Method: size ((transaction stream-transaction))
Generic Reader: target (object)

Returns the entry that the transaction is targeting.

See ENTRY
See TRANSACTION

Package

org.shirakumo.depot.

Methods
Reader Method: target ((transaction transaction))

automatically generated reader method

Source

protocol.lisp.

Target Slot

entry.

Generic Function: to-pathname (entry)

Returns a pathname that this entry represents.

This operation may also be used for entries that do not come from a file system depot, but the success of the operation is not guaranteed, as it is subject to implementation pathname constraints that may not apply to the depot or entry in question.

See FROM-PATHNAME

Package

org.shirakumo.depot.

Source

pathname.lisp.

Methods
Reader Method: to-pathname ((file file))

automatically generated reader method

Target Slot

pathname.

Reader Method: to-pathname ((directory directory))

automatically generated reader method

Target Slot

pathname.

Method: to-pathname ((entry entry))
Generic Function: to-stream (transaction)

Turns the transaction object into a STREAM object that can be passed to other agnostic libraries.

Note that many operations on the stream can be significantly more
expensive than if done through transactions’ READ-FROM/WRITE-TO
functions, and some stream operations may not be entirely supported.

See TRANSACTION

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: to-stream ((transaction input-transaction))
Method: to-stream ((transaction output-transaction))
Reader Method: to-stream ((stream-transaction stream-transaction))

automatically generated reader method

Target Slot

stream.

Generic Reader: transaction (object)
Package

org.shirakumo.depot.

Methods
Reader Method: transaction ((transaction-stream transaction-stream))

automatically generated reader method

Source

protocol.lisp.

Target Slot

transaction.

Generic Function: write-to (transaction sequence &key start end &allow-other-keys)

Write a sequence to a transaction.

TRANSACTION must be an object obtained through OPEN-ENTRY with the DIRECTION set to :OUTPUT, and may not have been aborted, committed, or invalidated.

SEQUENCE must be a lisp sequence type. START and END may be indices into this sequence designating a subsequence to write.

If another write was committed after the transaction was created, but before this call an error of type WRITE-CONFLICT may be signalled.

You may also call this on an ENTRY directly, in which case it will construct a transaction, write the sequence, and immediately attempt to COMMIT it.

See OPEN-ENTRY
See TRANSACTION

Package

org.shirakumo.depot.

Source

protocol.lisp.

Methods
Method: write-to ((transaction stream-transaction) (sequence sequence) &key start end)
Method: write-to ((entry entry) (target vector) &rest args &key &allow-other-keys)

5.1.5 Standalone methods

Method: close ((entry entry) &key abort)
Source

protocol.lisp.

Method: close ((depot depot) &key abort)
Source

protocol.lisp.

Method: close ((stream transaction-stream) &key abort)
Source

protocol.lisp.

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

pathname.lisp.

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

pathname.lisp.

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

protocol.lisp.

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

protocol.lisp.

Method: stream-advance-to-column ((stream transaction-stream) col)
Package

sb-gray.

Source

protocol.lisp.

Method: stream-clear-input ((stream transaction-stream))
Package

sb-gray.

Source

protocol.lisp.

Method: stream-clear-output ((stream transaction-stream))
Package

sb-gray.

Source

protocol.lisp.

Method: (setf stream-file-position) ((stream transaction-stream))
Package

trivial-gray-streams.

Source

protocol.lisp.

Method: stream-file-position ((stream transaction-stream))
Package

trivial-gray-streams.

Source

protocol.lisp.

Method: stream-finish-output ((stream transaction-stream))
Package

sb-gray.

Source

protocol.lisp.

Method: stream-force-output ((stream transaction-stream))
Package

sb-gray.

Source

protocol.lisp.

Method: stream-fresh-line ((stream transaction-stream))
Package

sb-gray.

Source

protocol.lisp.

Method: stream-line-column ((stream transaction-stream))
Package

sb-gray.

Source

protocol.lisp.

Method: stream-listen ((stream transaction-stream))
Package

sb-gray.

Source

protocol.lisp.

Method: stream-peek-char ((stream transaction-stream))
Package

sb-gray.

Source

protocol.lisp.

Method: stream-read-byte ((stream transaction-stream))
Package

sb-gray.

Source

protocol.lisp.

Method: stream-read-char ((stream transaction-stream))
Package

sb-gray.

Source

protocol.lisp.

Method: stream-read-char-no-hang ((stream transaction-stream))
Package

sb-gray.

Source

protocol.lisp.

Method: stream-read-line ((stream transaction-stream))
Package

sb-gray.

Source

protocol.lisp.

Method: stream-read-sequence ((stream transaction-stream) seq start end &key)
Package

trivial-gray-streams.

Source

protocol.lisp.

Method: stream-start-line-p ((stream transaction-stream))
Package

sb-gray.

Source

protocol.lisp.

Method: stream-terpri ((stream transaction-stream))
Package

sb-gray.

Source

protocol.lisp.

Method: stream-unread-char ((stream transaction-stream) char)
Package

sb-gray.

Source

protocol.lisp.

Method: stream-write-byte ((stream transaction-stream) byte)
Package

sb-gray.

Source

protocol.lisp.

Method: stream-write-char ((stream transaction-stream) char)
Package

sb-gray.

Source

protocol.lisp.

Method: stream-write-sequence ((stream transaction-stream) seq start end &key)
Package

trivial-gray-streams.

Source

protocol.lisp.

Method: stream-write-string ((stream transaction-stream) string &optional start end)
Package

sb-gray.

Source

protocol.lisp.


5.1.6 Conditions

Condition: depot-condition

Base condition for all conditions in the context of depots.

See OBJECT

Package

org.shirakumo.depot.

Source

conditions.lisp.

Direct superclasses

condition.

Direct subclasses
Direct methods

object.

Direct slots
Slot: object
Initform

(quote (org.shirakumo.depot::arg! :object))

Initargs

:object

Readers

object.

Writers

This slot is read-only.

Condition: depot-full

Error signalled if a depot cannot accept further content.

See DEPOT-CONDITION

Package

org.shirakumo.depot.

Source

conditions.lisp.

Direct superclasses
Condition: entry-already-exists

Error signalled if the requested entry already exists.

See DEPOT-CONDITION
See ATTRIBUTES

Package

org.shirakumo.depot.

Source

conditions.lisp.

Direct superclasses
Direct methods

attributes.

Direct slots
Slot: attributes
Initform

(quote nil)

Initargs

:attributes

Readers

attributes.

Writers

This slot is read-only.

Condition: entry-does-not-exist

Error signalled if the entry to operate on no longer exists.

See DEPOT-CONDITION

Package

org.shirakumo.depot.

Source

conditions.lisp.

Direct superclasses
Condition: no-such-attribute

Error signalled if a requested attribute does not exist.

See DEPOT-CONDITION
See NAME

Package

org.shirakumo.depot.

Source

conditions.lisp.

Direct superclasses
Direct methods

name.

Direct slots
Slot: name
Initform

(quote (org.shirakumo.depot::arg! :name))

Initargs

:name

Readers

name.

Writers

This slot is read-only.

Condition: no-such-entry

Error signalled if a requested entry does not exist.

See DEPOT-CONDITION
See ID

Package

org.shirakumo.depot.

Source

conditions.lisp.

Direct superclasses
Direct methods

id.

Direct slots
Slot: id
Initform

(quote (org.shirakumo.depot::arg! :id))

Initargs

:id

Readers

id.

Writers

This slot is read-only.

Condition: not-a-depot

Error signalled when an object cannot be coerced to a depot.

See DEPOT-CONDITION

Package

org.shirakumo.depot.

Source

conditions.lisp.

Direct superclasses
Condition: permission-denied

Error signalled if an action cannot be performed due to security constraints.

See DEPOT-CONDITION

Package

org.shirakumo.depot.

Source

conditions.lisp.

Direct superclasses
Condition: read-invalidated

Error signalled when a read cannot be completed due to a conflict.

This usually happens when a write has been committed between the time the transaction was opened and the current read was attempted.

See TRANSACTION-ABORTED

Package

org.shirakumo.depot.

Source

conditions.lisp.

Direct superclasses

transaction-aborted.

Condition: transaction-aborted

Error signalled when a transaction has been aborted and can’t be used.

See DEPOT-CONDITION

Package

org.shirakumo.depot.

Source

conditions.lisp.

Direct superclasses
Direct subclasses
Condition: unsupported-operation

Error signalled when attempting an operation that is not supported by the depot implementation.

See DEPOT-CONDITION
See OPERATION

Package

org.shirakumo.depot.

Source

conditions.lisp.

Direct superclasses
Direct methods

operation.

Direct slots
Slot: operation
Initform

(quote (org.shirakumo.depot::arg! :operation))

Initargs

:operation

Readers

operation.

Writers

This slot is read-only.

Condition: write-conflict

Error signalled when a write cannot be commited due to an existing conflict.

This usually happens when a write has been committed between the time the transaction was opened and the current commit was attempted.

See TRANSACTION-ABORTED

Package

org.shirakumo.depot.

Source

conditions.lisp.

Direct superclasses

transaction-aborted.


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

5.1.7 Classes

Class: depot

Superclass for objects implementing the depot protocol.

When implementing a new depot subclass, the following generic functions SHOULD be implemented:

- LIST-ENTRIES
- MAKE-ENTRY

All other depot operations are implemented using fallback operations. You may however implement other, specialised methods as well should there be more efficient ways of implementing them.

See LIST-ENTRIES
See QUERY-ENTRIES
See QUERY-ENTRY
See ENTRY
See ENTRY-EXISTS-P
See MAKE-ENTRY
See ENSURE-DEPOT

Package

org.shirakumo.depot.

Source

protocol.lisp.

Direct subclasses
Direct methods
Class: device

Base class for pathname devices.

These correspond to pathname-device types.

See DEPOT

Package

org.shirakumo.depot.

Source

pathname.lisp.

Direct superclasses

directory.

Direct methods
Class: directory

Class representing directories on a standard operating system hierarchical file system.

This is both a DEPOT and an ENTRY.

See DEPOT
See ENTRY

Package

org.shirakumo.depot.

Source

pathname.lisp.

Direct superclasses
Direct subclasses

device.

Direct methods
Direct slots
Slot: depot
Initargs

:depot

Readers

depot.

Writers

This slot is read-only.

Slot: pathname
Package

common-lisp.

Initargs

:pathname

Readers

to-pathname.

Writers

This slot is read-only.

Class: entry

Superclass for objects implementing the entry protocol.

When implementing a new entry subclass, the following generic functions SHOULD be implemented:

- ATTRIBUTES
- (SETF ATTRIBUTES)
- DELETE-ENTRY
- OPEN-ENTRY

Any other entry operations are implemented using fallback operations. You may however implement other, specialised methods as well should there be more efficient ways of implementing them.

See DELETE-ENTRY
See ENTRY-MATCHES-P
See ATTRIBUTES
See ATTRIBUTE
See ID
See DEPOT
See ENSURE-DEPOT
See OPEN-ENTRY
See WRITE-TO
See READ-FROM

Package

org.shirakumo.depot.

Source

protocol.lisp.

Direct subclasses
Direct methods
Class: file

Class representing files on a standard operating system hierarchical file system.

See ENTRY

Package

org.shirakumo.depot.

Source

pathname.lisp.

Direct superclasses

entry.

Direct methods
Direct slots
Slot: depot
Initargs

:depot

Readers

depot.

Writers

This slot is read-only.

Slot: pathname
Package

common-lisp.

Initargs

:pathname

Readers

to-pathname.

Writers

This slot is read-only.

Class: file-read-transaction

Class representing a read transaction from a file.

See FILE
See OPEN-ENTRY
See TRANSACTION

Package

org.shirakumo.depot.

Source

pathname.lisp.

Direct superclasses
Direct methods

commit.

Class: file-write-transaction

Class representing a write transaction to a file.

The atomicity of the write is established by writing to a temporary file, which is then renamed to the existing file on commit.

See FILE
See OPEN-ENTRY
See TRANSACTION

Package

org.shirakumo.depot.

Source

pathname.lisp.

Direct superclasses
Direct methods
Class: host

Base class for pathname hosts.

These correspond to pathname-host types.

See DEPOT

Package

org.shirakumo.depot.

Source

pathname.lisp.

Direct superclasses

depot.

Direct methods
Class: input-transaction
Package

org.shirakumo.depot.

Source

protocol.lisp.

Direct superclasses

transaction.

Direct subclasses

file-read-transaction.

Direct methods

to-stream.

Class: os-depot

Base class for the operating system’s file system depot.

See *OS-DEPOT*
See DEPOT

Package

org.shirakumo.depot.

Source

pathname.lisp.

Direct superclasses

depot.

Direct methods
Class: output-transaction
Package

org.shirakumo.depot.

Source

protocol.lisp.

Direct superclasses

transaction.

Direct subclasses

file-write-transaction.

Direct methods

to-stream.

Class: realizer

Superclass for objects implementing the realizer protocol.

See REALIZE-ENTRY
See REGISTER-REALIZER
See REMOVE-REALIZER
See DEFINE-REALIZER

Package

org.shirakumo.depot.

Source

protocol.lisp.

Class: stream-transaction

Superclass for transactions that operate on a stream.

Automatically handles the implementation of SIZE and INDEX for file-streams.

For all streams, ABORT and COMMIT will simply close the stream. It is up to the subclass to establish the proper ABORT and COMMIT semantics.

For all streams, WRITE-TO and READ-FROM are implemented using WRITE-SEQUENCE and READ-SEQUENCE, respectively.

TO-STREAM is also implemented to simply return the underlying stream.

See TRANSACTION
See TO-STREAM

Package

org.shirakumo.depot.

Source

protocol.lisp.

Direct superclasses

transaction.

Direct subclasses

file-transaction.

Direct methods
Direct slots
Slot: stream
Package

common-lisp.

Initargs

:stream

Readers

to-stream.

Writers

This slot is read-only.

Class: transaction

Superclass for objects implementing the transaction protocol.

When implementing a new transaction subclass, the following generic functions SHOULD be implemented:

- SIZE
- INDEX
- ABORT
- COMMIT
- WRITE-TO
- READ-FROM

See TARGET
see WRITE-TO
See READ-FROM
See SIZE
See INDEX
See TO-STREAM
See COMMIT
See ABORT

Package

org.shirakumo.depot.

Source

protocol.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: entry
Initargs

:entry

Readers

target.

Writers

This slot is read-only.

Slot: element-type
Initargs

:element-type

Readers

element-type.

Writers

This slot is read-only.

Class: transaction-stream

Gray stream wrapper around a transaction object.

Attempts to implement all gray stream methods and translate them to depot transaction operations.

See TO-STREAM
See TRANSACTION

Package

org.shirakumo.depot.

Source

protocol.lisp.

Direct superclasses

fundamental-stream.

Direct subclasses
Direct methods
Direct slots
Slot: transaction
Initargs

:transaction

Readers

transaction.

Writers

This slot is read-only.


5.2 Internals


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

5.2.1 Special variables

Special Variable: *entry-realizers*
Package

org.shirakumo.depot.

Source

protocol.lisp.


5.2.2 Macros

Macro: define-condition* (name classes slots report &rest report-args)
Package

org.shirakumo.depot.

Source

conditions.lisp.


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

5.2.3 Ordinary functions

Function: arg! (initarg)
Package

org.shirakumo.depot.

Source

conditions.lisp.

Function: directory-p (path)
Package

org.shirakumo.depot.

Source

pathname.lisp.

Function: normalize-path-component (comp)
Package

org.shirakumo.depot.

Source

pathname.lisp.

Function: path-component-specific-p (comp)
Package

org.shirakumo.depot.

Source

pathname.lisp.


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

5.2.4 Generic functions

Generic Reader: timestamp (object)
Package

org.shirakumo.depot.

Methods
Reader Method: timestamp ((file-transaction file-transaction))

automatically generated reader method

Source

pathname.lisp.

Target Slot

timestamp.

Generic Reader: unread (object)
Package

org.shirakumo.depot.

Methods
Reader Method: unread ((transaction-input-stream transaction-input-stream))

automatically generated reader method

Source

protocol.lisp.

Target Slot

unread.

Generic Writer: (setf unread) (object)
Package

org.shirakumo.depot.

Methods
Writer Method: (setf unread) ((transaction-input-stream transaction-input-stream))

automatically generated writer method

Source

protocol.lisp.

Target Slot

unread.


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

5.2.5 Classes

Class: file-transaction
Package

org.shirakumo.depot.

Source

pathname.lisp.

Direct superclasses

stream-transaction.

Direct subclasses
Direct methods

timestamp.

Direct slots
Slot: timestamp
Initargs

:timestamp

Readers

timestamp.

Writers

This slot is read-only.

Class: transaction-binary-input-stream
Package

org.shirakumo.depot.

Source

protocol.lisp.

Direct superclasses
Class: transaction-binary-output-stream
Package

org.shirakumo.depot.

Source

protocol.lisp.

Direct superclasses
Class: transaction-character-input-stream
Package

org.shirakumo.depot.

Source

protocol.lisp.

Direct superclasses
Class: transaction-character-output-stream
Package

org.shirakumo.depot.

Source

protocol.lisp.

Direct superclasses
Class: transaction-input-stream
Package

org.shirakumo.depot.

Source

protocol.lisp.

Direct superclasses
Direct subclasses
Direct methods
Direct slots
Slot: unread
Readers

unread.

Writers

(setf unread).

Class: transaction-output-stream
Package

org.shirakumo.depot.

Source

protocol.lisp.

Direct superclasses
Direct subclasses

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   I   L   M   N   O   P   Q   R   S   T   U   W  
Index Entry  Section

(
(setf attribute): Public generic functions
(setf attribute): Public generic functions
(setf attributes): Public generic functions
(setf attributes): Public generic functions
(setf index): Public generic functions
(setf index): Public generic functions
(setf stream-file-position): Public standalone methods
(setf unread): Private generic functions
(setf unread): Private generic functions

A
abort: Public generic functions
abort: Public generic functions
abort: Public generic functions
arg!: Private ordinary functions
attribute: Public generic functions
attribute: Public generic functions
attribute: Public generic functions
attribute: Public generic functions
attribute: Public generic functions
attribute: Public generic functions
attribute: Public generic functions
attributes: Public generic functions
attributes: Public generic functions
attributes: Public generic functions
attributes: Public generic functions
attributes: Public generic functions
attributes: Public generic functions
attributes: Public generic functions

C
close: Public standalone methods
close: Public standalone methods
close: Public standalone methods
commit: Public generic functions
commit: Public generic functions
commit: Public generic functions
commit: Public generic functions
commit: Public generic functions
commit: Public generic functions

D
define-condition*: Private macros
define-realizer: Public macros
delete-entry: Public generic functions
delete-entry: Public generic functions
delete-entry: Public generic functions
depot: Public generic functions
depot: Public generic functions
depot: Public generic functions
depot: Public generic functions
depot: Public generic functions
directory-p: Private ordinary functions

E
element-type: Public generic functions
element-type: Public generic functions
ensure-depot: Public generic functions
ensure-depot: Public generic functions
ensure-depot: Public generic functions
ensure-depot: Public generic functions
ensure-entry: Public generic functions
ensure-entry: Public generic functions
entry: Public generic functions
entry: Public generic functions
entry: Public generic functions
entry*: Public ordinary functions
entry-exists-p: Public generic functions
entry-exists-p: Public generic functions
entry-exists-p: Public generic functions
entry-matches-p: Public generic functions
entry-matches-p: Public generic functions

F
from-pathname: Public ordinary functions
Function, arg!: Private ordinary functions
Function, directory-p: Private ordinary functions
Function, entry*: Public ordinary functions
Function, from-pathname: Public ordinary functions
Function, normalize-path-component: Private ordinary functions
Function, path-component-specific-p: Private ordinary functions
Function, register-realizer: Public ordinary functions
Function, remove-realizer: Public ordinary functions

G
Generic Function, (setf attribute): Public generic functions
Generic Function, (setf attributes): Public generic functions
Generic Function, (setf index): Public generic functions
Generic Function, (setf unread): Private generic functions
Generic Function, abort: Public generic functions
Generic Function, attribute: Public generic functions
Generic Function, attributes: Public generic functions
Generic Function, commit: Public generic functions
Generic Function, delete-entry: Public generic functions
Generic Function, depot: Public generic functions
Generic Function, element-type: Public generic functions
Generic Function, ensure-depot: Public generic functions
Generic Function, ensure-entry: Public generic functions
Generic Function, entry: Public generic functions
Generic Function, entry-exists-p: Public generic functions
Generic Function, entry-matches-p: Public generic functions
Generic Function, id: Public generic functions
Generic Function, index: Public generic functions
Generic Function, list-entries: Public generic functions
Generic Function, make-entry: Public generic functions
Generic Function, name: Public generic functions
Generic Function, object: Public generic functions
Generic Function, open-entry: Public generic functions
Generic Function, operation: Public generic functions
Generic Function, query-entries: Public generic functions
Generic Function, query-entry: Public generic functions
Generic Function, read-from: Public generic functions
Generic Function, realize-entry: Public generic functions
Generic Function, size: Public generic functions
Generic Function, target: Public generic functions
Generic Function, timestamp: Private generic functions
Generic Function, to-pathname: Public generic functions
Generic Function, to-stream: Public generic functions
Generic Function, transaction: Public generic functions
Generic Function, unread: Private generic functions
Generic Function, write-to: Public generic functions

I
id: Public generic functions
id: Public generic functions
id: Public generic functions
id: Public generic functions
id: Public generic functions
id: Public generic functions
id: Public generic functions
index: Public generic functions
index: Public generic functions
index: Public generic functions

L
list-entries: Public generic functions
list-entries: Public generic functions
list-entries: Public generic functions
list-entries: Public generic functions
list-entries: Public generic functions

M
Macro, define-condition*: Private macros
Macro, define-realizer: Public macros
Macro, with-depot: Public macros
Macro, with-open: Public macros
make-entry: Public generic functions
make-entry: Public generic functions
make-entry: Public generic functions
Method, (setf attribute): Public generic functions
Method, (setf attributes): Public generic functions
Method, (setf index): Public generic functions
Method, (setf stream-file-position): Public standalone methods
Method, (setf unread): Private generic functions
Method, abort: Public generic functions
Method, abort: Public generic functions
Method, attribute: Public generic functions
Method, attribute: Public generic functions
Method, attribute: Public generic functions
Method, attribute: Public generic functions
Method, attribute: Public generic functions
Method, attribute: Public generic functions
Method, attributes: Public generic functions
Method, attributes: Public generic functions
Method, attributes: Public generic functions
Method, attributes: Public generic functions
Method, attributes: Public generic functions
Method, attributes: Public generic functions
Method, close: Public standalone methods
Method, close: Public standalone methods
Method, close: Public standalone methods
Method, commit: Public generic functions
Method, commit: Public generic functions
Method, commit: Public generic functions
Method, commit: Public generic functions
Method, commit: Public generic functions
Method, delete-entry: Public generic functions
Method, delete-entry: Public generic functions
Method, depot: Public generic functions
Method, depot: Public generic functions
Method, depot: Public generic functions
Method, depot: Public generic functions
Method, element-type: Public generic functions
Method, ensure-depot: Public generic functions
Method, ensure-depot: Public generic functions
Method, ensure-depot: Public generic functions
Method, ensure-entry: Public generic functions
Method, entry: Public generic functions
Method, entry: Public generic functions
Method, entry-exists-p: Public generic functions
Method, entry-exists-p: Public generic functions
Method, entry-matches-p: Public generic functions
Method, id: Public generic functions
Method, id: Public generic functions
Method, id: Public generic functions
Method, id: Public generic functions
Method, id: Public generic functions
Method, id: Public generic functions
Method, index: Public generic functions
Method, index: Public generic functions
Method, list-entries: Public generic functions
Method, list-entries: Public generic functions
Method, list-entries: Public generic functions
Method, list-entries: Public generic functions
Method, make-entry: Public generic functions
Method, make-entry: Public generic functions
Method, name: Public generic functions
Method, object: Public generic functions
Method, open-entry: Public generic functions
Method, open-entry: Public generic functions
Method, open-entry: Public generic functions
Method, operation: Public generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, query-entries: Public generic functions
Method, query-entries: Public generic functions
Method, query-entries: Public generic functions
Method, query-entry: Public generic functions
Method, query-entry: Public generic functions
Method, query-entry: Public generic functions
Method, read-from: Public generic functions
Method, read-from: Public generic functions
Method, read-from: Public generic functions
Method, read-from: Public generic functions
Method, read-from: Public generic functions
Method, read-from: Public generic functions
Method, realize-entry: Public generic functions
Method, realize-entry: Public generic functions
Method, realize-entry: Public generic functions
Method, size: Public generic functions
Method, size: Public generic functions
Method, stream-advance-to-column: Public standalone methods
Method, stream-clear-input: Public standalone methods
Method, stream-clear-output: Public standalone methods
Method, stream-file-position: Public standalone methods
Method, stream-finish-output: Public standalone methods
Method, stream-force-output: Public standalone methods
Method, stream-fresh-line: Public standalone methods
Method, stream-line-column: Public standalone methods
Method, stream-listen: Public standalone methods
Method, stream-peek-char: Public standalone methods
Method, stream-read-byte: Public standalone methods
Method, stream-read-char: Public standalone methods
Method, stream-read-char-no-hang: Public standalone methods
Method, stream-read-line: Public standalone methods
Method, stream-read-sequence: Public standalone methods
Method, stream-start-line-p: Public standalone methods
Method, stream-terpri: Public standalone methods
Method, stream-unread-char: Public standalone methods
Method, stream-write-byte: Public standalone methods
Method, stream-write-char: Public standalone methods
Method, stream-write-sequence: Public standalone methods
Method, stream-write-string: Public standalone methods
Method, target: Public generic functions
Method, timestamp: Private generic functions
Method, to-pathname: Public generic functions
Method, to-pathname: Public generic functions
Method, to-pathname: Public generic functions
Method, to-stream: Public generic functions
Method, to-stream: Public generic functions
Method, to-stream: Public generic functions
Method, transaction: Public generic functions
Method, unread: Private generic functions
Method, write-to: Public generic functions
Method, write-to: Public generic functions

N
name: Public generic functions
name: Public generic functions
normalize-path-component: Private ordinary functions

O
object: Public generic functions
object: Public generic functions
open-entry: Public generic functions
open-entry: Public generic functions
open-entry: Public generic functions
open-entry: Public generic functions
operation: Public generic functions
operation: Public generic functions

P
path-component-specific-p: Private ordinary functions
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods

Q
query-entries: Public generic functions
query-entries: Public generic functions
query-entries: Public generic functions
query-entries: Public generic functions
query-entry: Public generic functions
query-entry: Public generic functions
query-entry: Public generic functions
query-entry: Public generic functions

R
read-from: Public generic functions
read-from: Public generic functions
read-from: Public generic functions
read-from: Public generic functions
read-from: Public generic functions
read-from: Public generic functions
read-from: Public generic functions
realize-entry: Public generic functions
realize-entry: Public generic functions
realize-entry: Public generic functions
realize-entry: Public generic functions
register-realizer: Public ordinary functions
remove-realizer: Public ordinary functions

S
size: Public generic functions
size: Public generic functions
size: Public generic functions
stream-advance-to-column: Public standalone methods
stream-clear-input: Public standalone methods
stream-clear-output: Public standalone methods
stream-file-position: Public standalone methods
stream-finish-output: Public standalone methods
stream-force-output: Public standalone methods
stream-fresh-line: Public standalone methods
stream-line-column: Public standalone methods
stream-listen: Public standalone methods
stream-peek-char: Public standalone methods
stream-read-byte: Public standalone methods
stream-read-char: Public standalone methods
stream-read-char-no-hang: Public standalone methods
stream-read-line: Public standalone methods
stream-read-sequence: Public standalone methods
stream-start-line-p: Public standalone methods
stream-terpri: Public standalone methods
stream-unread-char: Public standalone methods
stream-write-byte: Public standalone methods
stream-write-char: Public standalone methods
stream-write-sequence: Public standalone methods
stream-write-string: Public standalone methods

T
target: Public generic functions
target: Public generic functions
timestamp: Private generic functions
timestamp: Private generic functions
to-pathname: Public generic functions
to-pathname: Public generic functions
to-pathname: Public generic functions
to-pathname: Public generic functions
to-stream: Public generic functions
to-stream: Public generic functions
to-stream: Public generic functions
to-stream: Public generic functions
transaction: Public generic functions
transaction: Public generic functions

U
unread: Private generic functions
unread: Private generic functions

W
with-depot: Public macros
with-open: Public macros
write-to: Public generic functions
write-to: Public generic functions
write-to: Public generic functions

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

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

A.4 Data types

Jump to:   C   D   E   F   H   I   N   O   P   R   S   T   U   W  
Index Entry  Section

C
Class, depot: Public classes
Class, device: Public classes
Class, directory: Public classes
Class, entry: Public classes
Class, file: Public classes
Class, file-read-transaction: Public classes
Class, file-transaction: Private classes
Class, file-write-transaction: Public classes
Class, host: Public classes
Class, input-transaction: Public classes
Class, os-depot: Public classes
Class, output-transaction: Public classes
Class, realizer: Public classes
Class, stream-transaction: Public classes
Class, transaction: Public classes
Class, transaction-binary-input-stream: Private classes
Class, transaction-binary-output-stream: Private classes
Class, transaction-character-input-stream: Private classes
Class, transaction-character-output-stream: Private classes
Class, transaction-input-stream: Private classes
Class, transaction-output-stream: Private classes
Class, transaction-stream: Public classes
Condition, depot-condition: Public conditions
Condition, depot-full: Public conditions
Condition, entry-already-exists: Public conditions
Condition, entry-does-not-exist: Public conditions
Condition, no-such-attribute: Public conditions
Condition, no-such-entry: Public conditions
Condition, not-a-depot: Public conditions
Condition, permission-denied: Public conditions
Condition, read-invalidated: Public conditions
Condition, transaction-aborted: Public conditions
Condition, unsupported-operation: Public conditions
Condition, write-conflict: Public conditions
conditions.lisp: The depot/conditions․lisp file

D
depot: The depot system
depot: Public classes
depot-condition: Public conditions
depot-full: Public conditions
depot.asd: The depot/depot․asd file
device: Public classes
directory: Public classes
documentation.lisp: The depot/documentation․lisp file

E
entry: Public classes
entry-already-exists: Public conditions
entry-does-not-exist: Public conditions

F
file: Public classes
File, conditions.lisp: The depot/conditions․lisp file
File, depot.asd: The depot/depot․asd file
File, documentation.lisp: The depot/documentation․lisp file
File, package.lisp: The depot/package․lisp file
File, pathname.lisp: The depot/pathname․lisp file
File, protocol.lisp: The depot/protocol․lisp file
file-read-transaction: Public classes
file-transaction: Private classes
file-write-transaction: Public classes

H
host: Public classes

I
input-transaction: Public classes

N
no-such-attribute: Public conditions
no-such-entry: Public conditions
not-a-depot: Public conditions

O
org.shirakumo.depot: The org․shirakumo․depot package
os-depot: Public classes
output-transaction: Public classes

P
Package, org.shirakumo.depot: The org․shirakumo․depot package
package.lisp: The depot/package․lisp file
pathname.lisp: The depot/pathname․lisp file
permission-denied: Public conditions
protocol.lisp: The depot/protocol․lisp file

R
read-invalidated: Public conditions
realizer: Public classes

S
stream-transaction: Public classes
System, depot: The depot system

T
transaction: Public classes
transaction-aborted: Public conditions
transaction-binary-input-stream: Private classes
transaction-binary-output-stream: Private classes
transaction-character-input-stream: Private classes
transaction-character-output-stream: Private classes
transaction-input-stream: Private classes
transaction-output-stream: Private classes
transaction-stream: Public classes

U
unsupported-operation: Public conditions

W
write-conflict: Public conditions

Jump to:   C   D   E   F   H   I   N   O   P   R   S   T   U   W