The depot Reference Manual

Table of Contents

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 3.0 "Montgomery Scott" on Wed Oct 13 10:43:03 2021 GMT+0.


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

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 (via depot-zip)

## 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.


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

2 Systems

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


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

2.1 depot

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

Description

Protocol for transparent collections of files.

Version

1.0.0

Dependencies
Source

depot.asd (file)

Components

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

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 files   [Contents][Index]

3.1.1 depot.asd

Location

depot.asd

Systems

depot (system)


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

3.1.2 depot/package.lisp

Parent

depot (system)

Location

package.lisp

Packages

org.shirakumo.depot


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

3.1.3 depot/conditions.lisp

Dependency

package.lisp (file)

Parent

depot (system)

Location

conditions.lisp

Exported Definitions
Internal Definitions

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

3.1.4 depot/protocol.lisp

Dependency

conditions.lisp (file)

Parent

depot (system)

Location

protocol.lisp

Exported Definitions
Internal Definitions

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

3.1.5 depot/pathname.lisp

Dependency

protocol.lisp (file)

Parent

depot (system)

Location

pathname.lisp

Exported Definitions
Internal Definitions

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

3.1.6 depot/documentation.lisp

Dependency

pathname.lisp (file)

Parent

depot (system)

Location

documentation.lisp


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

4 Packages

Packages are listed by definition order.


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

4.1 org.shirakumo.depot

Source

package.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [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 (file)


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

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 (file)

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 (file)


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

5.1.3 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 (file)

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.

Returns a FILE or DIRECTORY.

See TO-PATHNAME
See FILE
See DIRECTORY

Package

org.shirakumo.depot

Source

pathname.lisp (file)

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 (file)

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 (file)


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

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 (file)

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

pathname.lisp (file)

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 (file)

Writer

(setf attribute) (generic function)

Methods
Method: attribute (NAME (eql author)) (ENTRY file)
Source

pathname.lisp (file)

Method: attribute (NAME (eql write-date)) (ENTRY file)
Source

pathname.lisp (file)

Method: attribute (NAME (eql type)) (ENTRY file)
Source

pathname.lisp (file)

Method: attribute (NAME (eql name)) (ENTRY file)
Source

pathname.lisp (file)

Method: attribute (NAME (eql author)) (ENTRY directory)
Source

pathname.lisp (file)

Method: attribute NAME (ENTRY entry)
Generic Function: (setf attribute) VALUE NAME ENTRY
Package

org.shirakumo.depot

Source

protocol.lisp (file)

Reader

attribute (generic function)

Methods
Method: (setf attribute) VALUE 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 (file)

Writer

(setf attributes) (generic function)

Methods
Method: attributes (ENTRY file)
Source

pathname.lisp (file)

Method: attributes (ENTRY directory)
Source

pathname.lisp (file)

Method: attributes (DEPOT device)
Source

pathname.lisp (file)

Method: attributes (DEPOT host)
Source

pathname.lisp (file)

Method: attributes (ENTRY entry)
Method: attributes (CONDITION entry-already-exists)
Source

conditions.lisp (file)

Generic Function: (setf attributes) ATTRIBUTES ENTRY
Package

org.shirakumo.depot

Source

protocol.lisp (file)

Reader

attributes (generic function)

Methods
Method: (setf attributes) 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 (file)

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

pathname.lisp (file)

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

pathname.lisp (file)

Method: commit (TRANSACTION stream-transaction) &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 (file)

Methods
Method: delete-entry (ENTRY file)
Source

pathname.lisp (file)

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 (file)

Methods
Method: depot (DEPOT device)
Source

pathname.lisp (file)

Method: depot (DEPOT host)
Source

pathname.lisp (file)

Method: depot (FILE file)

automatically generated reader method

Source

pathname.lisp (file)

Method: depot (DIRECTORY directory)

automatically generated reader method

Source

pathname.lisp (file)

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 (file)

Methods
Method: ensure-depot (ENTRY entry)
Method: ensure-depot (DEPOT depot)
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 (file)

Methods
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 (file)

Methods
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 (file)

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 (file)

Methods
Method: id (DEPOT device)
Source

pathname.lisp (file)

Method: id (DEPOT host)
Source

pathname.lisp (file)

Method: id (ENTRY file)
Source

pathname.lisp (file)

Method: id (ENTRY directory)
Source

pathname.lisp (file)

Method: id (ENTRY entry)
Method: id (CONDITION no-such-entry)
Source

conditions.lisp (file)

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 (file)

Writer

(setf index) (generic function)

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

org.shirakumo.depot

Source

protocol.lisp (file)

Reader

index (generic function)

Methods
Method: (setf index) 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 (file)

Methods
Method: list-entries (DEPOT host)
Source

pathname.lisp (file)

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

pathname.lisp (file)

Method: list-entries (DEPOT directory)
Source

pathname.lisp (file)

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 (file)

Methods
Method: make-entry (DEPOT directory) &key NAME TYPE ID
Source

pathname.lisp (file)

Method: make-entry (DEPOT depot) &key
Generic Function: name CONDITION

Returns the name of the attribute.

See NO-SUCH-ATTRIBUTE

Package

org.shirakumo.depot

Methods
Method: name (CONDITION no-such-attribute)
Source

conditions.lisp (file)

Generic Function: object CONDITION

Returns the object that the condition relates to.

See DEPOT-CONDITION

Package

org.shirakumo.depot

Methods
Method: object (CONDITION depot-condition)
Source

conditions.lisp (file)

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 (file)

Methods
Method: open-entry (FILE file) (DIRECTION (eql input)) ELEMENT-TYPE &key EXTERNAL-FORMAT
Source

pathname.lisp (file)

Method: open-entry (FILE file) (DIRECTION (eql output)) ELEMENT-TYPE &key EXTERNAL-FORMAT
Source

pathname.lisp (file)

Method: open-entry (ENTRY entry) DIRECTION ELEMENT-TYPE &key
Generic Function: operation CONDITION

Returns the name of the operation that failed.

See UNSUPPORTED-OPERATION

Package

org.shirakumo.depot

Methods
Method: operation (CONDITION unsupported-operation)
Source

conditions.lisp (file)

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 (file)

Methods
Method: query-entries (DEPOT os-depot) &key (HOST _)
Source

pathname.lisp (file)

Method: query-entries (DEPOT directory) &key NAME TYPE VERSION ID
Source

pathname.lisp (file)

Method: query-entries (DEPOT depot) &rest ARGS &key &allow-other-keys
Generic Function: query-entry DEPOT &key 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 (file)

Methods
Method: query-entry (DEPOT host) &key DEVICE
Source

pathname.lisp (file)

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 (file)

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 (file)

Methods
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 (file)

Methods
Method: size (TRANSACTION stream-transaction)
Generic Function: target OBJECT

Returns the entry that the transaction is targeting.

See ENTRY
See TRANSACTION

Package

org.shirakumo.depot

Methods
Method: target (TRANSACTION transaction)

automatically generated reader method

Source

protocol.lisp (file)

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 (file)

Methods
Method: to-pathname (FILE file)

automatically generated reader method

Method: to-pathname (DIRECTORY directory)

automatically generated reader method

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 (file)

Methods
Method: to-stream (TRANSACTION transaction)
Method: to-stream (STREAM-TRANSACTION stream-transaction)

automatically generated reader method

Generic Function: transaction OBJECT
Package

org.shirakumo.depot

Methods
Method: transaction (TRANSACTION-STREAM transaction-stream)

automatically generated reader method

Source

protocol.lisp (file)

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 (file)

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

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

5.1.5 Conditions

Condition: depot-condition ()

Base condition for all conditions in the context of depots.

See OBJECT

Package

org.shirakumo.depot

Source

conditions.lisp (file)

Direct superclasses

condition (condition)

Direct subclasses
Direct methods

object (method)

Direct slots
Slot: object
Initargs

:object

Initform

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

Readers

object (generic function)

Condition: depot-full ()

Error signalled if a depot cannot accept further content.

See DEPOT-CONDITION

Package

org.shirakumo.depot

Source

conditions.lisp (file)

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 (file)

Direct superclasses
Direct methods

attributes (method)

Direct slots
Slot: attributes
Initargs

:attributes

Initform

(quote nil)

Readers

attributes (generic function)

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 (file)

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 (file)

Direct superclasses
Direct methods

name (method)

Direct slots
Slot: name
Initargs

:name

Initform

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

Readers

name (generic function)

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 (file)

Direct superclasses
Direct methods

id (method)

Direct slots
Slot: id
Initargs

:id

Initform

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

Readers

id (generic function)

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 (file)

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 (file)

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 (file)

Direct superclasses

transaction-aborted (condition)

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 (file)

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 (file)

Direct superclasses
Direct methods

operation (method)

Direct slots
Slot: operation
Initargs

:operation

Initform

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

Readers

operation (generic function)

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 (file)

Direct superclasses

transaction-aborted (condition)


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

5.1.6 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 (file)

Direct superclasses

standard-object (class)

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 (file)

Direct superclasses

directory (class)

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 (file)

Direct superclasses
Direct subclasses

device (class)

Direct methods
Direct slots
Slot: depot
Initargs

:depot

Readers

depot (generic function)

Slot: pathname
Initargs

:pathname

Readers

to-pathname (generic function)

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 (file)

Direct superclasses

standard-object (class)

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 (file)

Direct superclasses

entry (class)

Direct methods
Direct slots
Slot: depot
Initargs

:depot

Readers

depot (generic function)

Slot: pathname
Initargs

:pathname

Readers

to-pathname (generic function)

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 (file)

Direct superclasses

file-transaction (class)

Direct methods

commit (method)

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 (file)

Direct superclasses

file-transaction (class)

Direct methods
Class: host ()

Base class for pathname hosts.

These correspond to pathname-host types.

See DEPOT

Package

org.shirakumo.depot

Source

pathname.lisp (file)

Direct superclasses

depot (class)

Direct methods
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 (file)

Direct superclasses

depot (class)

Direct methods
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 (file)

Direct superclasses

standard-object (class)

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 (file)

Direct superclasses

transaction (class)

Direct subclasses

file-transaction (class)

Direct methods
Direct slots
Slot: stream
Initargs

:stream

Readers

to-stream (generic function)

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 (file)

Direct superclasses

standard-object (class)

Direct subclasses

stream-transaction (class)

Direct methods
Direct slots
Slot: entry
Initargs

:entry

Readers

target (generic function)

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 (file)

Direct superclasses

fundamental-stream (class)

Direct methods
  • stream-file-position (method)
  • stream-file-position (method)
  • stream-write-sequence (method)
  • stream-read-sequence (method)
  • stream-write-byte (method)
  • stream-read-byte (method)
  • stream-advance-to-column (method)
  • stream-clear-output (method)
  • stream-force-output (method)
  • stream-finish-output (method)
  • stream-fresh-line (method)
  • stream-terpri (method)
  • stream-write-string (method)
  • stream-start-line-p (method)
  • stream-line-column (method)
  • stream-write-char (method)
  • stream-clear-input (method)
  • stream-read-line (method)
  • stream-listen (method)
  • stream-peek-char (method)
  • stream-read-char-no-hang (method)
  • stream-unread-char (method)
  • stream-read-char (method)
  • close (method)
  • unread (method)
  • unread (method)
  • transaction (method)
Direct slots
Slot: transaction
Initargs

:transaction

Readers

transaction (generic function)

Slot: unread
Readers

unread (generic function)

Writers

(setf unread) (generic function)


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

5.2 Internal definitions


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

5.2.1 Special variables

Special Variable: *entry-realizers*
Package

org.shirakumo.depot

Source

protocol.lisp (file)


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

5.2.2 Macros

Macro: define-condition* NAME CLASSES SLOTS REPORT &rest REPORT-ARGS
Package

org.shirakumo.depot

Source

conditions.lisp (file)


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

5.2.3 Functions

Function: arg! INITARG
Package

org.shirakumo.depot

Source

conditions.lisp (file)

Function: normalize-path-component COMP
Package

org.shirakumo.depot

Source

pathname.lisp (file)

Function: path-component-specific-p COMP
Package

org.shirakumo.depot

Source

pathname.lisp (file)


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

5.2.4 Generic functions

Generic Function: timestamp OBJECT
Package

org.shirakumo.depot

Methods
Method: timestamp (FILE-TRANSACTION file-transaction)

automatically generated reader method

Source

pathname.lisp (file)

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

org.shirakumo.depot

Methods
Method: unread (TRANSACTION-STREAM transaction-stream)

automatically generated reader method

Source

protocol.lisp (file)

Method: (setf unread) NEW-VALUE (TRANSACTION-STREAM transaction-stream)

automatically generated writer method

Source

protocol.lisp (file)


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

5.2.5 Classes

Class: file-transaction ()
Package

org.shirakumo.depot

Source

pathname.lisp (file)

Direct superclasses

stream-transaction (class)

Direct subclasses
Direct methods

timestamp (method)

Direct slots
Slot: timestamp
Initargs

:timestamp

Readers

timestamp (generic function)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   D   F   L  
Index Entry  Section

D
depot.asd: The depot․asd file
depot/conditions.lisp: The depot/conditions․lisp file
depot/documentation.lisp: The depot/documentation․lisp file
depot/package.lisp: The depot/package․lisp file
depot/pathname.lisp: The depot/pathname․lisp file
depot/protocol.lisp: The depot/protocol․lisp file

F
File, Lisp, depot.asd: The depot․asd file
File, Lisp, depot/conditions.lisp: The depot/conditions․lisp file
File, Lisp, depot/documentation.lisp: The depot/documentation․lisp file
File, Lisp, depot/package.lisp: The depot/package․lisp file
File, Lisp, depot/pathname.lisp: The depot/pathname․lisp file
File, Lisp, depot/protocol.lisp: The depot/protocol․lisp file

L
Lisp File, depot.asd: The depot․asd file
Lisp File, depot/conditions.lisp: The depot/conditions․lisp file
Lisp File, depot/documentation.lisp: The depot/documentation․lisp file
Lisp File, depot/package.lisp: The depot/package․lisp file
Lisp File, depot/pathname.lisp: The depot/pathname․lisp file
Lisp File, depot/protocol.lisp: The depot/protocol․lisp file

Jump to:   D   F   L  

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): Exported generic functions
(setf attribute): Exported generic functions
(setf attributes): Exported generic functions
(setf attributes): Exported generic functions
(setf index): Exported generic functions
(setf index): Exported generic functions
(setf unread): Internal generic functions
(setf unread): Internal generic functions

A
abort: Exported generic functions
abort: Exported generic functions
abort: Exported generic functions
arg!: Internal functions
attribute: Exported generic functions
attribute: Exported generic functions
attribute: Exported generic functions
attribute: Exported generic functions
attribute: Exported generic functions
attribute: Exported generic functions
attribute: Exported generic functions
attributes: Exported generic functions
attributes: Exported generic functions
attributes: Exported generic functions
attributes: Exported generic functions
attributes: Exported generic functions
attributes: Exported generic functions
attributes: Exported generic functions

C
commit: Exported generic functions
commit: Exported generic functions
commit: Exported generic functions
commit: Exported generic functions

D
define-condition*: Internal macros
define-realizer: Exported macros
delete-entry: Exported generic functions
delete-entry: Exported generic functions
delete-entry: Exported generic functions
depot: Exported generic functions
depot: Exported generic functions
depot: Exported generic functions
depot: Exported generic functions
depot: Exported generic functions

E
ensure-depot: Exported generic functions
ensure-depot: Exported generic functions
ensure-depot: Exported generic functions
entry: Exported generic functions
entry: Exported generic functions
entry*: Exported functions
entry-exists-p: Exported generic functions
entry-exists-p: Exported generic functions
entry-matches-p: Exported generic functions
entry-matches-p: Exported generic functions

F
from-pathname: Exported functions
Function, arg!: Internal functions
Function, entry*: Exported functions
Function, from-pathname: Exported functions
Function, normalize-path-component: Internal functions
Function, path-component-specific-p: Internal functions
Function, register-realizer: Exported functions
Function, remove-realizer: Exported functions

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

I
id: Exported generic functions
id: Exported generic functions
id: Exported generic functions
id: Exported generic functions
id: Exported generic functions
id: Exported generic functions
id: Exported generic functions
index: Exported generic functions
index: Exported generic functions

L
list-entries: Exported generic functions
list-entries: Exported generic functions
list-entries: Exported generic functions
list-entries: Exported generic functions
list-entries: Exported generic functions

M
Macro, define-condition*: Internal macros
Macro, define-realizer: Exported macros
Macro, with-open: Exported macros
make-entry: Exported generic functions
make-entry: Exported generic functions
make-entry: Exported generic functions
Method, (setf attribute): Exported generic functions
Method, (setf attributes): Exported generic functions
Method, (setf index): Exported generic functions
Method, (setf unread): Internal generic functions
Method, abort: Exported generic functions
Method, abort: Exported generic functions
Method, attribute: Exported generic functions
Method, attribute: Exported generic functions
Method, attribute: Exported generic functions
Method, attribute: Exported generic functions
Method, attribute: Exported generic functions
Method, attribute: Exported generic functions
Method, attributes: Exported generic functions
Method, attributes: Exported generic functions
Method, attributes: Exported generic functions
Method, attributes: Exported generic functions
Method, attributes: Exported generic functions
Method, attributes: Exported generic functions
Method, commit: Exported generic functions
Method, commit: Exported generic functions
Method, commit: Exported generic functions
Method, delete-entry: Exported generic functions
Method, delete-entry: Exported generic functions
Method, depot: Exported generic functions
Method, depot: Exported generic functions
Method, depot: Exported generic functions
Method, depot: Exported generic functions
Method, ensure-depot: Exported generic functions
Method, ensure-depot: Exported generic functions
Method, entry: Exported generic functions
Method, entry-exists-p: Exported generic functions
Method, entry-matches-p: Exported generic functions
Method, id: Exported generic functions
Method, id: Exported generic functions
Method, id: Exported generic functions
Method, id: Exported generic functions
Method, id: Exported generic functions
Method, id: Exported generic functions
Method, index: Exported generic functions
Method, list-entries: Exported generic functions
Method, list-entries: Exported generic functions
Method, list-entries: Exported generic functions
Method, list-entries: Exported generic functions
Method, make-entry: Exported generic functions
Method, make-entry: Exported generic functions
Method, name: Exported generic functions
Method, object: Exported generic functions
Method, open-entry: Exported generic functions
Method, open-entry: Exported generic functions
Method, open-entry: Exported generic functions
Method, operation: Exported generic functions
Method, query-entries: Exported generic functions
Method, query-entries: Exported generic functions
Method, query-entries: Exported generic functions
Method, query-entry: Exported generic functions
Method, query-entry: Exported generic functions
Method, read-from: Exported generic functions
Method, read-from: Exported generic functions
Method, read-from: Exported generic functions
Method, read-from: Exported generic functions
Method, read-from: Exported generic functions
Method, read-from: Exported generic functions
Method, realize-entry: Exported generic functions
Method, realize-entry: Exported generic functions
Method, size: Exported generic functions
Method, target: Exported generic functions
Method, timestamp: Internal generic functions
Method, to-pathname: Exported generic functions
Method, to-pathname: Exported generic functions
Method, to-pathname: Exported generic functions
Method, to-stream: Exported generic functions
Method, to-stream: Exported generic functions
Method, transaction: Exported generic functions
Method, unread: Internal generic functions
Method, write-to: Exported generic functions
Method, write-to: Exported generic functions

N
name: Exported generic functions
name: Exported generic functions
normalize-path-component: Internal functions

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

P
path-component-specific-p: Internal functions

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

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

S
size: Exported generic functions
size: Exported generic functions

T
target: Exported generic functions
target: Exported generic functions
timestamp: Internal generic functions
timestamp: Internal generic functions
to-pathname: Exported generic functions
to-pathname: Exported generic functions
to-pathname: Exported generic functions
to-pathname: Exported generic functions
to-stream: Exported generic functions
to-stream: Exported generic functions
to-stream: Exported generic functions
transaction: Exported generic functions
transaction: Exported generic functions

U
unread: Internal generic functions
unread: Internal generic functions

W
with-open: Exported macros
write-to: Exported generic functions
write-to: Exported generic functions
write-to: Exported generic functions

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

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

A.3 Variables

Jump to:   *  
A   D   E   I   N   O   P   S   T   U  
Index Entry  Section

*
*entry-realizers*: Internal special variables
*os-depot*: Exported special variables

A
attributes: Exported conditions

D
depot: Exported classes
depot: Exported classes

E
entry: Exported classes

I
id: Exported conditions

N
name: Exported conditions

O
object: Exported conditions
operation: Exported conditions

P
pathname: Exported classes
pathname: Exported classes

S
Slot, attributes: Exported conditions
Slot, depot: Exported classes
Slot, depot: Exported classes
Slot, entry: Exported classes
Slot, id: Exported conditions
Slot, name: Exported conditions
Slot, object: Exported conditions
Slot, operation: Exported conditions
Slot, pathname: Exported classes
Slot, pathname: Exported classes
Slot, stream: Exported classes
Slot, timestamp: Internal classes
Slot, transaction: Exported classes
Slot, unread: Exported classes
Special Variable, *entry-realizers*: Internal special variables
Special Variable, *os-depot*: Exported special variables
stream: Exported classes

T
timestamp: Internal classes
transaction: Exported classes

U
unread: Exported classes

Jump to:   *  
A   D   E   I   N   O   P   S   T   U  

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

A.4 Data types

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

C
Class, depot: Exported classes
Class, device: Exported classes
Class, directory: Exported classes
Class, entry: Exported classes
Class, file: Exported classes
Class, file-read-transaction: Exported classes
Class, file-transaction: Internal classes
Class, file-write-transaction: Exported classes
Class, host: Exported classes
Class, os-depot: Exported classes
Class, realizer: Exported classes
Class, stream-transaction: Exported classes
Class, transaction: Exported classes
Class, transaction-stream: Exported classes
Condition, depot-condition: Exported conditions
Condition, depot-full: Exported conditions
Condition, entry-already-exists: Exported conditions
Condition, entry-does-not-exist: Exported conditions
Condition, no-such-attribute: Exported conditions
Condition, no-such-entry: Exported conditions
Condition, not-a-depot: Exported conditions
Condition, permission-denied: Exported conditions
Condition, read-invalidated: Exported conditions
Condition, transaction-aborted: Exported conditions
Condition, unsupported-operation: Exported conditions
Condition, write-conflict: Exported conditions

D
depot: The depot system
depot: Exported classes
depot-condition: Exported conditions
depot-full: Exported conditions
device: Exported classes
directory: Exported classes

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

F
file: Exported classes
file-read-transaction: Exported classes
file-transaction: Internal classes
file-write-transaction: Exported classes

H
host: Exported classes

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

O
org.shirakumo.depot: The org․shirakumo․depot package
os-depot: Exported classes

P
Package, org.shirakumo.depot: The org․shirakumo․depot package
permission-denied: Exported conditions

R
read-invalidated: Exported conditions
realizer: Exported classes

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

T
transaction: Exported classes
transaction-aborted: Exported conditions
transaction-stream: Exported classes

U
unsupported-operation: Exported conditions

W
write-conflict: Exported conditions

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