The configuration.options Reference Manual

Table of Contents

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

The configuration.options Reference Manual

This is the configuration.options Reference Manual, version 0.7.0, generated automatically by Declt version 2.3 "Robert April" on Tue Feb 20 08:31:34 2018 GMT+0.


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

1 Introduction

#+TITLE:       configuration.options README
#+AUTHOR:      Jan Moringen
#+EMAIL:       jmoringe@techfak.uni-bielefeld.de
#+DESCRIPTION: Description, tutorial and reference for the configuration.options system
#+KEYWORDS:    common lisp, options, configuration
#+LANGUAGE:    en

* Introduction
  The =configuration.options= system provides
  + data structures and functions for hierarchical configuration
    schemata and options
  + sources of option values (builtin sources are configuration files,
    environment variables and commandline options)
  + and handling of changes of option values
  All of these aspects are extensible via protocols.

  #+ATTR_HTML: :alt "build status image" :title Build Status :align right
  [[https://travis-ci.org/scymtym/configuration.options][https://travis-ci.org/scymtym/configuration.options.svg]]

* STARTED Tutorial

  #+BEGIN_SRC lisp :exports results :results silent
    (defun first-line-or-less (string)
      (let ((end (min 70 (or (position #\Newline string) (length string)))))
        (subseq string 0 end)))

    (defun provider-table (service)
     (loop :for (name . provider) :in (service-provider:service-providers/alist service)
        :collect `(,name ,(first-line-or-less (documentation provider t)))))

    (defun provider-table/sorted (service)
      (sort (provider-table service) #'string< :key #'first))
  #+END_SRC

  Implementing configuration processing using the
  =configuration.options= system involves at least three steps:
  1. [[*Specifying a Schema]]
  2. [[*Constructing and Populating a Configuration]] based on the schema
  3. [[*Querying a Configuration]]

** Names
   Since options (and the corresponding schema items) are organized
   into a hierarchy, option names are a sequence of multiple
   components. The notation =COMPONENT₁.COMPONENT₂.…= is used when
   representing names as strings.

   "Wildcard names" are names in which one or more components is
   ~:wild~ or ~:wild-inferiors~.

   The following functions deal with names:
   #+BEGIN_SRC lisp  :results values :exports results :colnames '("Form" "Result")
     (mapcar (lambda (example)
               (destructuring-bind (function arguments) example
                 (let ((*package* (find-package :configuration.options)))
                   (list (format nil "(~(~A~)~{ ~S~})" (symbol-name function) arguments)
                         (prin1-to-string (apply function arguments))))))
             `((configuration.options:parse-name      ("a.b.\"c.d\""))
               (configuration.options:make-name       ("a.b.c"))
               (configuration.options:make-name       ("a.*.c"))
               (configuration.options:make-name       ("a.**.c"))
               (configuration.options:make-name       (("a" "b" "c")))
               (configuration.options:name-components (,(configuration.options:make-name "a.**.c")))
               (configuration.options:name-equal      (,(configuration.options:make-name "a.b.c")
                                                        ,(configuration.options:make-name "d.e.f")))
               (configuration.options:name-matches    (,(configuration.options:make-name "d.**.g")
                                                        ,(configuration.options:make-name "d.e.f.g")))
               (configuration.options:name-equal      (,(configuration.options:make-name "a.b.c")
                                                        ,(configuration.options:make-name "d.e.f")))
               (configuration.options:merge-names     (,(configuration.options:make-name "a.b.c")
                                                       ,(configuration.options:make-name "d.e.f")))))
   #+END_SRC

   #+RESULTS:
   | Form                                                                  | Result                               |
   |-----------------------------------------------------------------------+--------------------------------------|
   | (parse-name "a.b.\"c.d\"")                                            | ("a" "b" "c.d")                      |
   | (make-name "a.b.c")                                                   | ("a" "b" "c")                        |
   | (make-name "a.*.c")                                                   | #  |
   | (make-name "a.**.c")                                                  | # |
   | (make-name ("a" "b" "c"))                                             | ("a" "b" "c")                        |
   | (name-components #)                | ("a" :WILD-INFERIORS "c")            |
   | (name-equal ("a" "b" "c") ("d" "e" "f"))                              | NIL                                  |
   | (name-matches # ("d" "e" "f" "g")) | T                                    |
   | (name-equal ("a" "b" "c") ("d" "e" "f"))                              | NIL                                  |
   | (merge-names ("a" "b" "c") ("d" "e" "f"))                             | ("a" "b" "c" "d" "e" "f")            |

** Specifying a Schema
   A schema can be defined in multiple ways:

   + "Manually" via multiple function and method calls
   + Declaratively using ~configuration.options:eval-schema-spec~
   + Declaratively using ~configuration.options:define-schema~

   Since the third method is likely the most commonly used (and uses
   the same syntax as the second method), it is probably sufficient to
   only discuss ~configuration.options:define-schema~. Here is an
   example:
   #+BEGIN_SRC lisp :results silent :exports both
     (configuration.options:define-schema *my-schema*
       "Configuration schema for my program."
       ("logging"
        ("appender"                :type    '(member :file :standard-output)
                                   :default :standard-output
                                   :documentation
                                   "Appender to use.")
        ((:wild-inferiors "level") :type    '(member :info :warning :error)
                                   :documentation
                                   "Package/module/component log level.")))
   #+END_SRC
   The above code creates a schema object and stores it in the
   parameter ~*my-schema*~. The schema consists of two items:

   1. ~logging.appender~ with allowed values ~:file~ and
      ~:standard-output~ and default value ~:standard-output~

   2. a "template" option named =logging.**.level= with allowed values
      ~:info~, ~:warning~ and ~:error~ and without a default value

   #+BEGIN_SRC lisp :results output :exports both
     (describe *my-schema*)
   #+END_SRC

   #+RESULTS:
   #+begin_example
   #

   Tree:
     
     │ Configuration schema for my program.
     └─logging
       ├─appender
       │   Type    (MEMBER FILE STANDARD-OUTPUT)
       │   Default :STANDARD-OUTPUT
       │   Appender to use.
       └─**
         └─level
             Type    (MEMBER INFO WARNING ERROR)
             Default 
             Package/module/component log level.
   #+end_example

*** TODO Sub-schemata

** Constructing and Populating a Configuration
   Configurations are created from schemata by first creating an empty
   configuration object and then populating it with option objects
   corresponding to schema item objects in the schema:

   #+BEGIN_SRC lisp :results silent :exports both
     (defparameter *my-configuration* (configuration.options:make-configuration *my-schema*))
   #+END_SRC

   The created configuration is empty:

   #+BEGIN_SRC lisp :results output :exports both
     (describe *my-configuration*)
   #+END_SRC

   #+RESULTS:
   #+begin_example
   #

   Tree:
     
   #+end_example

   There are several ways to create option objects from schema item
   objects:

   1. "Manually", options can be created using the ~make-option~
      generic function (this also works if the corresponding to schema
      items have wild names):

      #+BEGIN_SRC lisp :exports both
        (let* ((name        "logging.mypackage.myparser.level")
               (schema-item (configuration.options:find-option
                             name *my-schema*
                             :interpret-wildcards? :container)))
          (setf (configuration.options:find-option name *my-configuration*)
                (configuration.options:make-option schema-item name)))
      #+END_SRC

      #+RESULTS:
      : # {100B8A4FE3}>

      Note that the schema item named =logging.**.level= matches the
      requested name because of its ~:wild-inferiors~ name
      component. Also note that creating an option object does not
      automatically assign a value to it (even if the schema item
      specifies a default value).

      The schema item lookup and ~make-option~ call in the above code
      can be done automatically, shortening the example to:

      #+BEGIN_SRC lisp :exports both
        (configuration.options:find-option
         "logging.mypackage.mylexer.level" *my-configuration*
         :if-does-not-exist :create)
      #+END_SRC

      #+RESULTS:
      : # {100B8DD5C3}>

   2. Using a "synchronizer" which integrates data from sources such
      as configuration files into configuration objects:

      #+BEGIN_SRC lisp :results silent :exports both
        (defun populate-configuration (schema configuration)
          (let ((synchronizer (make-instance 'configuration.options:standard-synchronizer
                                             :target configuration))
                (source       (configuration.options.sources:make-source :defaults)))
            (configuration.options.sources:initialize source schema)
            (configuration.options.sources:process source synchronizer)))

        (populate-configuration *my-schema* *my-configuration*)
      #+END_SRC

      The above example uses the simple "default values" source which
      instantiates option objects for all schema items with non-wild
      names and sets their values to the respective default values (if
      any) stored in corresponding schema items.

   After creating these option objects, the configuration looks like
   this:

   #+BEGIN_SRC lisp :results output :exports both
     (describe *my-configuration*)
   #+END_SRC

   #+RESULTS:
   #+begin_example
   #

   Tree:
     
     └─logging
       ├─appender
       │   Type    (MEMBER FILE STANDARD-OUTPUT)
       │   Default :STANDARD-OUTPUT
       │   Value   :STANDARD-OUTPUT
       │   Sources DEFAULT:
       │             :STANDARD-OUTPUT
       │   Appender to use.
       └─mypackage
         ├─mylexer
         │ └─level
         │     Type    (MEMBER INFO WARNING ERROR)
         │     Default 
         │     Value   
         │     Package/module/component log level.
         └─myparser
           └─level
               Type    (MEMBER INFO WARNING ERROR)
               Default 
               Value   
               Package/module/component log level.
   #+end_example

   In a more realistic setting, populating the configuration would be
   done exclusively using a synchronizer but with a "cascade" of
   sources [fn:1] instead of just the "default values" source.

** TODO Querying a Configuration
** TODO Tracking Changes of Option Values
** More on Sources
   [[*Constructing and Populating a Configuration]] introduced the
   "source" and "synchronizer" concepts by demonstrating the default
   values source.

   In more realistic settings, a combination of multiple sources like
   (from highest to lowest priority)

   1. Commandline options
   2. Environment variables
   3. Configuration file(s) and directories
   4. Default values

   will be used. Cascades of this kind can be constructed by
   instantiating the ~:cascade~ source with appropriate subordinate
   sources:

   #+BEGIN_SRC lisp :exports both :resuts value
     (configuration.options.sources:make-source
      :cascade
      :sources '((:commandline)
                 (:environment-variables)
                 (:config-file-cascade :config-file "my-program.conf"
                                       :syntax      :ini)
                 (:defaults)))
   #+END_SRC

   #+RESULTS:
   : #

   A similar cascade of sources is constructed by the
   ~:common-cascade~ source without the need for manually specifying
   the involved sources.

   #+BEGIN_SRC lisp :exports both :results value
     (configuration.options.sources:make-source
      :common-cascade :basename "my-program" :syntax :ini)
   #+END_SRC

   #+RESULTS:
   : #

   Currently available sources are:

   #+BEGIN_SRC lisp :exports results :results value table :colnames '("Name" "Documentation")
     (provider-table/sorted 'configuration.options.sources::source)
   #+END_SRC

   #+RESULTS:
   | Name                   | Documentation                                                        |
   |------------------------+----------------------------------------------------------------------|
   | :CASCADE               | This source organizes a set of sources into a prioritized cascade.   |
   | :COMMANDLINE           | This source obtains option values from commandline arguments.        |
   | :COMMON-CASCADE        | This source implements a typical cascade for commandline programs.   |
   | :CONFIG-FILE-CASCADE   | This source implements a cascade of file-based sources.              |
   | :DEFAULTS              | This source assigns default values to options.                       |
   | :DIRECTORY             | Collects config files and creates corresponding subordinate sources. |
   | :ENVIRONMENT-VARIABLES | This source reads values of environment variables.                   |
   | :FILE                  | This source reads configuration data from files.                     |
   | :STREAM                | This source reads and configuration data from streams.               |

   The ~:stream~ (and therefore ~:file~, ~:config-file-cascade~ and
   ~:common-cascade~) source supports the following syntaxes:

   #+BEGIN_SRC lisp :exports results :results value table :colnames '("Name" "Documentation")
     (provider-table/sorted 'configuration.options.sources::syntax)
   #+END_SRC

   #+RESULTS:
   | Name | Documentation                                            |
   |------+----------------------------------------------------------|
   | :INI | Parse textual configuration information in "ini" syntax. |
   | :XML | This syntax allows using some kinds of XML documents as  |

** STARTED Configuration Debugging

   With multiple configuration sources such as environment variables
   and various configuration files, it can sometimes be hard to
   understand how a particular option got its value (or did not get an
   expected value). This is true in particular for users who cannot
   poke around inside the program.

   To alleviate this problem, the =configuration.options= system
   provides a simple configuration debugging facility aimed at
   users. This facility can be enabled by calling

   + ~(configuration.options.debug:enable-debugging STREAM)~ ::

        To enable debug output to ~STREAM~ unconditionally

   + ~(configuration.options.debug:maybe-enable-debugging PREFIX :stream STREAM)~ ::

        To enable debug output to ~STREAM~ if the environment variable
        =PREFIXCONFIG_DEBUG= is set

   The intention is that a program using this system calls one of
   these functions before configuration processing starts.

   For example, using the schema defined [[*Specifying a Schema][above]]:

   #+BEGIN_SRC lisp :exports both :results output
     (setf (uiop:getenv "MY_PROGRAM_LOGGING_APPENDER") "file")

     (configuration.options.debug:enable-debugging *standard-output*)

     (let* ((schema        *my-schema*)
            (configuration (configuration.options:make-configuration schema))
            (synchronizer  (make-instance 'configuration.options:standard-synchronizer
                                          :target configuration))
            (source        (configuration.options.sources:make-source
                            :common-cascade :basename "my-program" :syntax :ini)))
       (configuration.options.sources:initialize source schema)
       (configuration.options.sources:process source synchronizer))
   #+END_SRC

   #+RESULTS:
   #+begin_example
   Configuring COMMON-CASCADE-SOURCE with child sources (highest priority first)

     1. Environment variables with prefix mapping
        MY_PROGRAM_LOGGING_APPENDER=file (mapped to logging.appender) -> "file"

     2. Configuring CONFIG-FILE-CASCADE-SOURCE with child sources (highest priority first)

        1. Current directory file "my-program.conf" does not exist

        2. User config file "/home/jmoringe/.config/my-program.conf" does not exist

        3. System-wide config file "/etc/my-program.conf" does not exist

#+end_example

* STARTED Integration with the =architecture.service-provider= System

  The [[https://github.com/scymtym/architecture.service-provider][architecture.service-provider system]] allows defining services
  and providers of these services. The integration described here adds
  the ability to automatically define a configuration schema for a
  given service and use a configuration object to choose, instantiate
  and configure a provider:

  #+BEGIN_SRC dot :file "service-provider-integration.png" :exports results
    digraph {

      rankdir="LR"
      node [shape="box"]

      service
      provider1 [shape=record,label="provider 1|slot a: boolean"]
      service -> provider1 [arrowhead="none",weight=1000]
      service -> provider2 [arrowhead="none"]

      derive_schema [label="derive schema",shape="ellipse"]
      schema [shape="record",label="schema|item provider: (member 1 2)|item 1.a: boolean"]
      service -> derive_schema -> schema

      make_configuration [label="make configuration",shape="ellipse"]
      configuration [shape="record",label="configuration|option provider = 1|option 1.a = t"]
      schema -> make_configuration
      make_configuration -> configuration
      provider1 -> configuration [style="dashed",label="selects",arrowtail="normal",dir="back",weight=0]

      instantiate_provider [label="instantiate provider", shape="ellipse"]
      instance [shape="record",label="instance|slot a = t"]
      configuration -> instantiate_provider
      instantiate_provider -> instance
      provider1 -> instance [arrowtail="emptytriangle",dir="back",weight=0]
    }
  #+END_SRC

  #+RESULTS:
  [[file:service-provider-integration.png]]

  This functionionality is provided in the separate
  ~configuration.options-and-service-provider~ system:

  #+BEGIN_SRC lisp :results silent :exports both
    (asdf:load-system :configuration.options-and-service-provider)
  #+END_SRC

** STARTED Deriving a Schema for A Schema

   #+BEGIN_SRC lisp :results output :exports both
     (service-provider:define-service my-service)

     (defclass my-provider () ((a :initarg :a :type string)))
     (service-provider:register-provider/class
      'my-service :my-provider :class 'my-provider)

     (describe
      (configuration.options.service-provider:service-schema
       (service-provider:find-service 'my-service)))
   #+END_SRC

   #+RESULTS:
   #+begin_example
   #

   Tree:
     
     │ Configuration options of the MY-SERVICE service.
     ├─provider
     │   Type    (PROVIDER-DESIGNATOR-MEMBER MY-PROVIDER)
     │   Default 
     │   Selects one of the providers of the MY-SERVICE service for
     │   instantiation.
     └─my-provider
       │ Configuration of the MY-PROVIDER provider.
       └─a
           Type    STRING
           Default 
   #+end_example

** STARTED Creating a Configured Provider

   #+BEGIN_SRC lisp :results output :exports both
     (let* ((schema        (configuration.options.service-provider:service-schema
                            'my-service))
            (configuration (configuration.options:make-configuration schema)))

       (populate-configuration schema configuration)
       (setf (configuration.options:option-value
              (configuration.options:find-option "provider" configuration))
             :my-provider
             (configuration.options:option-value
              (configuration.options:find-option "my-provider.a" configuration))
             "foo")

       (describe (service-provider:make-provider 'my-service configuration)))
   #+END_SRC

   #+RESULTS:
   #+begin_example
   #
     [standard-object]

   Slots with :INSTANCE allocation:
     A  = "foo"
   #+end_example

** TODO Tracking Service Changes

* TODO Reference
* TODO Related Work
  + https://github.com/Shinmera/universal-config/
  + https://github.com/Shinmera/ubiquitous
  + https://docs.python.org/3/library/configparser.html
  + cl-config

* Settings                                                         :noexport:

#+OPTIONS: H:2 num:nil toc:t \n:nil @:t ::t |:t ^:t -:t f:t *:t <:t
#+OPTIONS: TeX:t LaTeX:t skip:nil d:nil todo:t pri:nil tags:not-in-toc
#+SEQ_TODO: TODO STARTED | DONE

* Footnotes

[fn:1] See [[*More on Sources]]


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 configuration.options

Maintainer

Jan Moringen <jmoringe@techfak.uni-bielefeld.de>

Author

Jan Moringen <jmoringe@techfak.uni-bielefeld.de>

Home Page

https://github.com/scymtym/configuration.options

Source Control

(:git "https://github.com/scymtym/configuration.options.git")

Bug Tracker

https://github.com/scymtym/configuration.options/issues

License

LLGPLv3

Description

An extensible configuration system that supports multiple option sources.

Version

0.7.0

Dependencies
Source

configuration.options.asd (file)

Components

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

3 Modules

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


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

3.1 configuration.options/src

Parent

configuration.options (system)

Location

src/

Components

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

3.2 configuration.options/sources

Dependency

src (module)

Parent

configuration.options (system)

Location

src/sources/

Components

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

4 Files

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


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

4.1 Lisp


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

4.1.1 configuration.options.asd

Location

configuration.options.asd

Systems

configuration.options (system)


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

4.1.2 configuration.options/src/package.lisp

Parent

src (module)

Location

src/package.lisp

Packages

configuration.options


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

4.1.3 configuration.options/src/types.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

src/types.lisp

Exported Definitions
Internal Definitions

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

4.1.4 configuration.options/src/variables.lisp

Dependency

types.lisp (file)

Parent

src (module)

Location

src/variables.lisp

Exported Definitions

*configuration* (special variable)

Internal Definitions

+no-value+ (constant)


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

4.1.5 configuration.options/src/conditions.lisp

Dependency

variables.lisp (file)

Parent

src (module)

Location

src/conditions.lisp

Exported Definitions
Internal Definitions

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

4.1.6 configuration.options/src/protocol.lisp

Dependency

conditions.lisp (file)

Parent

src (module)

Location

src/protocol.lisp

Exported Definitions
Internal Definitions

if-name (macro)


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

4.1.7 configuration.options/src/util.lisp

Dependency

protocol.lisp (file)

Parent

src (module)

Location

src/util.lisp

Internal Definitions

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

4.1.8 configuration.options/src/mixins.lisp

Dependency

util.lisp (file)

Parent

src (module)

Location

src/mixins.lisp

Exported Definitions
Internal Definitions

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

4.1.9 configuration.options/src/name.lisp

Dependency

mixins.lisp (file)

Parent

src (module)

Location

src/name.lisp

Exported Definitions
Internal Definitions

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

4.1.10 configuration.options/src/schema.lisp

Dependency

name.lisp (file)

Parent

src (module)

Location

src/schema.lisp

Exported Definitions
Internal Definitions

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

4.1.11 configuration.options/src/configuration.lisp

Dependency

schema.lisp (file)

Parent

src (module)

Location

src/configuration.lisp

Exported Definitions
Internal Definitions

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

4.1.12 configuration.options/src/value-types.lisp

Dependency

configuration.lisp (file)

Parent

src (module)

Location

src/value-types.lisp

Exported Definitions
Internal Definitions

%maybe-check-detailed-type (function)


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

4.1.13 configuration.options/src/synchronizer.lisp

Dependency

value-types.lisp (file)

Parent

src (module)

Location

src/synchronizer.lisp

Exported Definitions
Internal Definitions

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

4.1.14 configuration.options/src/macros.lisp

Dependency

synchronizer.lisp (file)

Parent

src (module)

Location

src/macros.lisp

Exported Definitions

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

4.1.15 configuration.options/src/let-plus.lisp

Dependency

macros.lisp (file)

Parent

src (module)

Location

src/let-plus.lisp

Exported Definitions
Internal Definitions

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

4.1.16 configuration.options/src/debug.lisp

Dependency

let-plus.lisp (file)

Parent

src (module)

Location

src/debug.lisp

Packages

configuration.options.debug

Exported Definitions
Internal Definitions

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

4.1.17 configuration.options/sources/package.lisp

Parent

sources (module)

Location

src/sources/package.lisp

Packages

configuration.options.sources


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

4.1.18 configuration.options/sources/conditions.lisp

Dependency

package.lisp (file)

Parent

sources (module)

Location

src/sources/conditions.lisp

Exported Definitions

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

4.1.19 configuration.options/sources/protocol.lisp

Dependency

conditions.lisp (file)

Parent

sources (module)

Location

src/sources/protocol.lisp

Exported Definitions

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

4.1.20 configuration.options/sources/debug.lisp

Dependency

protocol.lisp (file)

Parent

sources (module)

Location

src/sources/debug.lisp

Internal Definitions

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

4.1.21 configuration.options/sources/configuration-files.lisp

Dependency

debug.lisp (file)

Parent

sources (module)

Location

src/sources/configuration-files.lisp

Exported Definitions
Internal Definitions

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

4.1.22 configuration.options/sources/source-defaults.lisp

Dependency

configuration-files.lisp (file)

Parent

sources (module)

Location

src/sources/source-defaults.lisp

Exported Definitions
Internal Definitions

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

4.1.23 configuration.options/sources/source-environment-variables.lisp

Dependency

source-defaults.lisp (file)

Parent

sources (module)

Location

src/sources/source-environment-variables.lisp

Exported Definitions

process (method)

Internal Definitions

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

4.1.24 configuration.options/sources/source-stream.lisp

Dependency

source-environment-variables.lisp (file)

Parent

sources (module)

Location

src/sources/source-stream.lisp

Exported Definitions

process (method)

Internal Definitions

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

4.1.25 configuration.options/sources/source-file.lisp

Dependency

source-stream.lisp (file)

Parent

sources (module)

Location

src/sources/source-file.lisp

Exported Definitions

process (method)

Internal Definitions

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

4.1.26 configuration.options/sources/source-cascade.lisp

Dependency

source-file.lisp (file)

Parent

sources (module)

Location

src/sources/source-cascade.lisp

Exported Definitions
Internal Definitions

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

5 Packages

Packages are listed by definition order.


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

5.1 configuration.options

Options and option containers which are either parts of a
configuration or of a schema.

The basic structure is as follows:

Concept | Protocol | Class(es) | ——————+—————————-+————————–+ + container-like | container protocol | | + schema | schema protocol | ‘standard-schema’ | + configuration | configuration protocol | ‘standard-configuration’ | + option-like | option protocol | | + schema-item | schema item protocol class | ‘standard-schema-item’ | + option | option value protocol | ‘standard-option’ |

Population of configuration options with actual values is handled
by functions and classes in the ‘configuration.options.sources’ package.

Source

package.lisp (file)

Use List
Used By List

configuration.options.sources

Exported Definitions
Internal Definitions

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

5.2 configuration.options.debug

Functions for debugging configuration processing.

Source

debug.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

5.3 configuration.options.sources

This package contains configuration options sources.

Sources such as configuration files, environment variables and commandline options provide option discovery and option value events to sinks (usually a synchronizer) which usually integrate the information into a configuration object.

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

6 Definitions

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


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

6.1 Exported definitions


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

6.1.1 Constants

Constant: +config-debug-variable-suffix+

Suffix for the name of the environment variable controlling configuration debugging.

Package

configuration.options.debug

Source

debug.lisp (file)


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

6.1.2 Special variables

Special Variable: *configuration*

When bound to a configuration object, provides the default configuration for the ‘value’ and setf ‘value’ functions.

Package

configuration.options

Source

variables.lisp (file)


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

6.1.3 Macros

Macro: &options &rest ARGUMENTS

Like ‘&options-r/o’ but the bound variables are ‘setf’ able places. Setting the value of such a place sets the value of the corresponding option.

Package

configuration.options

Source

let-plus.lisp (file)

Macro: &options-r/o &rest ARGUMENTS

Execute BODY with established bindings of option values from the given ‘configuration’ object.

Bindings are specifications of the form

BINDING ::= VAR-AND-NAME | FULL-BINDING
VAR-AND-NAME ::= VAR | (VAR NAME)
FULL-BINDING ::= (VAR-AND-NAME [DEFAULT-VALUE [VALUE?-VAR]])

VAR is a symbol naming the variable to which the option value should be bound.

NAME is a string naming an option or an option name object. When NAME is not supplied, it is derived from VAR by downcasing the name of the symbol.

When the option named by NAME does not have a value and DEFAULT-VALUE is supplied, VAR is bound to DEFAULT-VALUE.

When VALUE?-VAR is supplied, it is bound to true when the option named by NAME has value and to false otherwise.

Package

configuration.options

Source

let-plus.lisp (file)

Macro: &options/synchronizer &rest ARGUMENTS

Similar to ‘&options’ but the value has to be a synchronizer instead of a ‘configuration’. When ‘setf’ is used on a place bound to an option, the synchronizer is used to set the new value.

Package

configuration.options

Source

let-plus.lisp (file)

Macro: define-schema NAME-AND-ARGS &body DOCSTRING-AND-SPECS

Define a parameter (like ‘cl:defparameter’) named according to
NAME-AND-ARGS the initial value of which is a schema as specified
by DOCSTRING-AND-SPECS.

NAME-AND-ARGS can either be a symbol which will be treated as a
name or a list starting with a symbol followed by keyword
arguments.

DOCSTRING-AND-SPECS is a list of schema and option
specifications (optionally preceded by a documentation string)
where each specification is of the form

SPEC ::= SCHEMA-SPEC | SCHEMA-VALUE-SPEC | OPTION-SPEC SCHEMA-SPEC ::= (NAME SPEC*)
SCHEMA-VALUE-SPEC ::= (NAME SCHEMA-VALUE)
OPTION-SPEC ::= (NAME &key type default documentation &allow-other-keys)

where SCHEMA-VALUE is evaluated and has to return a schema object.

The arguments of the type and default keyword parameters are
evaluated in the null lexical environment.

When DOCSTRING-AND-SPECS starts with a documentation string, it is
used as the documentation string of the toplevel schema object.

Example:

(define-schema *my-schema*
"Schema for my configuration"

("section"
("option" :type ’integer))) ; Note: :type argument is evaluated

Package

configuration.options

Source

macros.lisp (file)

Macro: with-indent (AMOUNT) &body BODY

Execute BODY with debug indentation increased by AMOUNT.

Package

configuration.options.debug

Source

debug.lisp (file)

Macro: with-level (LEVEL) &body BODY

Execute BODY with debug level LEVEL.

LEVEL can an integer or ‘:next’ to increase the current level by one.

Package

configuration.options.debug

Source

debug.lisp (file)


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

6.1.4 Functions

Function: call-with-indent AMOUNT THUNK

Call THUNK with debug indentation increased by AMOUNT.

Package

configuration.options.debug

Source

debug.lisp (file)

Function: call-with-level LEVEL THUNK

Call THUNK with debug level LEVEL.

LEVEL can an integer or ‘:next’ to increase the current level by one.

Package

configuration.options.debug

Source

debug.lisp (file)

Function: config-debug-variable-name PREFIX

Return environment variable name derived from PREFIX.

Package

configuration.options.debug

Source

debug.lisp (file)

Function: configuration-file-specs PREFIX

Return a list of configuration file specifications using PREFIX.

Elements of the returned list are either namestrings or the placeholders ‘+config-file-pwd-placeholder+’, ‘+config-file-user-placeholder+’ and ‘+config-file-system-placeholder+’.

PREFIX is used to compute the name of an environment variable PREFIX_CONFIG_FILES the value of which is split at ":" to produce the return value, if the variable is defined.

Otherwise the default list of configuration file specifications, which is the value of ‘*default-configuration-files*’, is returned.

Package

configuration.options.sources

Source

configuration-files.lisp (file)

Function: configuration-files FILENAME &key USER-HOMEDIR PREFIX FILE-SPECS

Return a list of configuration file descriptions based on FILENAME.

Each of the returned descriptions is a list of the form

(PATHNAME DESCRIPTION)

To produce the list of descriptions, FILENAME is combined with each of the specifications in FILE-SPECS. Such a specification can be

* file or directory pathnames which are merged with FILENAME

* the value of ‘+config-file-pwd-placeholder+’ (i.e. the string "%pwd") which represents a file named FILENAME in the current directory.

* the value of ‘+config-file-user-placeholder+’ (i.e. the string "%user") which represents a file named FILENAME in the user configuration directory as computed by ‘user-configuration-directory’ applied to USER-HOMEDIR.

* the value of ‘+config-file-system-placeholder+’ (i.e. the string "%system") which represents a file named FILENAME in the system configuration directory as computed by ‘system-configuration-directory’ applied to PREFIX.

Package

configuration.options.sources

Source

configuration-files.lisp (file)

Function: enable-debugging STREAM

Enable configuration debugging using stream.

Package

configuration.options.debug

Source

debug.lisp (file)

Function: eval-schema-spec SPEC &key DOCUMENTATION

Evaluate SPEC as a schema specification and return the resulting schema object.

If DOCUMENTATION is supplied, it is used as the documentation string of the toplevel schema item in SPEC.

Package

configuration.options

Source

macros.lisp (file)

Function: map-schema-spec FUNCTION SPEC

Call FUNCTION for each specification item in SPEC and return FUNCTION’s return value for the toplevel schema item in SPEC.

FUNCTION should have a lambda-list compatible to the following one

kind name rest &key prefix schema self

where KIND is one of :schema, :wild-schema and :item, NAME is the name of the currently processed item and REST is the
remainder (following the name) of the specification item when KIND is :item.

Package

configuration.options

Source

macros.lisp (file)

Function: maybe-enable-debugging PREFIX &key STREAM

Enable configuration debugging according to environment variable.

PREFIX is used with ‘config-debug-variable-name’ to compute the name of the environment variable.

STREAM is used for debug output if debugging is enabled.

Package

configuration.options.debug

Source

debug.lisp (file)

Function: output FORMAT-CONTROL &rest FORMAT-ARGUMENTS

Output FORMAT-CONTROL and FORMAT-ARGUMENTS if debugging.

Package

configuration.options.debug

Source

debug.lisp (file)

Function: parse-name STRING &key START END JUNK-ALLOWED WILD-ALLOWED WILD-INFERIORS-ALLOWED

Parse STRING as an option name and return the result.

START and END, when supplied, select a sub-string of STRING for parsing.

WILD-ALLOWED and WILD-INFERIORS-ALLOWED control whether "*" and "**" respectively are accepted as name components in STRING.

Package

configuration.options

Source

name.lisp (file)

Function: print-name STREAM NAME &optional COLON? AT? WIDTH

Print dot-separated components of NAME onto STREAM. If WIDTH is supplied pad output to WIDTH.

If COLON? is non-NIL, print the empty name as "<root>" instead of the empty string.

Package

configuration.options

Source

name.lisp (file)

Function: print-option-container-tree STREAM OBJECT &optional COLON? AT?
Package

configuration.options

Source

mixins.lisp (file)


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

6.1.5 Generic functions

Generic Function: binding-condition-container CONDITION
Package

configuration.options

Methods
Method: binding-condition-container (CONDITION binding-condition)
Source

conditions.lisp (file)

Generic Function: binding-condition-name CONDITION
Package

configuration.options

Methods
Method: binding-condition-name (CONDITION binding-condition)
Source

conditions.lisp (file)

Generic Function: binding-exists-condition-existing CONDITION
Package

configuration.options

Methods
Method: binding-exists-condition-existing (CONDITION binding-exists-condition)
Source

conditions.lisp (file)

Generic Function: configuration-schema CONFIGURATION

Return the schema object governing CONFIGURATION.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: configuration-schema (STANDARD-CONFIGURATION standard-configuration)

Stores the schema object associated to the configuration object.

Source

configuration.lisp (file)

Generic Function: event-hook OBJECT

Return the event hook, a ‘hooks:object-hook’, for OBJECT.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: event-hook (OBJECT event-hook-mixin)
Source

mixins.lisp (file)

Generic Function: find-child NAME SCHEMA &key IF-DOES-NOT-EXIST IF-EXISTS &allow-other-keys

Find and return the child schema stored under NAME in SCHEMA.

IF-DOES-NOT-EXIST controls the behavior in case there is no child schema named NAME in SCHEMA:

nil

Return nil.

other value (but not one of the following)

Return IF-DOES-NOT-EXIST.

’warn, #’warn

Signal a ‘child-missing-warning’ indicating that a child named NAME does not exist in SCHEMA and return nil.

’error, #’error

Signal a ‘child-missing-error’ indicating that a child named NAME does not exist in SCHEMA.

a function

Call the function with a ‘child-missing-error’ instance indicating that a child NAME NAME does not exist in SCHEMA.

IF-EXISTS is accepted for parity with ‘(setf find-child)’.

Package

configuration.options

Source

protocol.lisp (file)

Writer

(setf find-child) (generic function)

Methods
Method: find-child NAME (CONTAINER standard-schema) &key &allow-other-keys
Source

schema.lisp (file)

Method: find-child NAME SCHEMA &key IF-DOES-NOT-EXIST &allow-other-keys around
Method: find-child (NAME sequence) SCHEMA &rest ARGS &key &allow-other-keys around
Generic Function: (setf find-child) NEW-VALUE NAME SCHEMA &key IF-DOES-NOT-EXIST IF-EXISTS &allow-other-keys

Store the child schema NEW-VALUE under the name NAME in SCHEMA.

IF-DOES-NOT-EXIST acts similarly to what is described for ‘find-child’ w.r.t. signaling conditions, but does not influence the return value.

IF-EXISTS controls the behavior in case a child schema name is already stored in SCHEMA:

:supersede

Replace the existing child named NAME in SCHEMA with NEW-VALUE.

:keep

Do not store NEW-VALUE and keep the child currently associated to NAME in SCHEMA.

’warn, #’warn

Signal a ‘child-exists-warning’ indicating that a child named NAME already exists in SCHEMA.

’error, #’error

Signal a ‘child-exists-error’ indicating that a child named NAME already exists in SCHEMA.

a function

Call the function with a ‘child-exists-error’ indicating that a child named NAME already exists in SCHEMA.

Package

configuration.options

Source

protocol.lisp (file)

Reader

find-child (generic function)

Methods
Method: (setf find-child) NEW-VALUE NAME SCHEMA &key IF-DOES-NOT-EXIST IF-EXISTS around
Method: (setf find-child) NEW-VALUE (NAME sequence) SCHEMA &rest ARGS &key &allow-other-keys around
Method: (setf find-child) NEW-VALUE KEY (SCHEMA standard-schema) &key &allow-other-keys after
Source

schema.lisp (file)

Method: (setf find-child) NEW-VALUE (KEY sequence) (SCHEMA standard-schema) &key &allow-other-keys
Source

schema.lisp (file)

Generic Function: find-option NAME CONTAINER &key IF-DOES-NOT-EXIST IF-EXISTS INTERPRET-WILDCARDS? &allow-other-keys

Find and return the option named NAME in CONTAINER.

IF-DOES-NOT-EXIST controls the behavior in case there is no option named NAME:

nil

Return nil.

other value (but not one of the following)

Return IF-DOES-NOT-EXIST.

’warn, #’warn

Signal a ‘option-missing-warning’ indicating that an option named NAME does not exist in CONTAINER and return nil.

’error, #’error

Signal an ‘option-missing-error’ indicating that an option named NAME does not exist in CONTAINER.

a function

Call the function with an ‘option-missing-error’ instance indicating that an option named NAME does not exist in CONTAINER.

IF-EXISTS is accepted for parity with ‘(setf find-option)’.

Package

configuration.options

Source

protocol.lisp (file)

Writer

(setf find-option) (generic function)

Methods
Method: find-option NAME (CONTAINER standard-configuration) &key IF-DOES-NOT-EXIST &allow-other-keys around
Source

configuration.lisp (file)

Method: find-option NAME (CONTAINER standard-schema) &key INTERPRET-WILDCARDS? &allow-other-keys
Source

schema.lisp (file)

Method: find-option NAME (CONTAINER list-container-mixin) &key &allow-other-keys
Source

mixins.lisp (file)

Method: find-option NAME CONTAINER &key IF-DOES-NOT-EXIST &allow-other-keys around
Method: find-option (NAME sequence) CONTAINER &rest ARGS &key &allow-other-keys around
Generic Function: (setf find-option) NEW-VALUE NAME CONTAINER &key IF-DOES-NOT-EXIST IF-EXISTS &allow-other-keys

Store the option NEW-VALUE under the name NAME in container.

IF-DOES-NOT-EXIST acts similarly to what is described for ‘find-option’ w.r.t. signaling conditions, but does not influence the return value.

IF-EXISTS controls the behavior in case an option named NAME is already stored in CONTAINER:

:supersede

Replace the existing option named NAME in container with NEW-VALUE.

:keep

Do not store NEW-VALUE and keep the option currently associated to NAME in CONTAINER.

’warn, #’warn

Signal a ‘option-exists-warning’ indicating that an option named NAME already exists in CONTAINER.

’error, #’error

Signal an ‘option-exists-error’ indicating that an option named NAME already exists in CONTAINER.

a function

Call the function with an ‘option-exists-error’ instance indicating that an option named NAME already exists in CONTAINER.

Package

configuration.options

Source

protocol.lisp (file)

Reader

find-option (generic function)

Methods
Method: (setf find-option) NEW-VALUE NAME (CONTAINER list-container-mixin) &key &allow-other-keys after
Source

mixins.lisp (file)

Method: (setf find-option) NEW-VALUE NAME (CONTAINER list-container-mixin) &key &allow-other-keys
Source

mixins.lisp (file)

Method: (setf find-option) NEW-VALUE NAME (CONTAINER list-container-mixin) &key &allow-other-keys before
Source

mixins.lisp (file)

Method: (setf find-option) NEW-VALUE NAME CONTAINER &key IF-DOES-NOT-EXIST IF-EXISTS around
Method: (setf find-option) (NEW-VALUE (eql nil)) NAME CONTAINER &key IF-DOES-NOT-EXIST IF-EXISTS around
Method: (setf find-option) NEW-VALUE (NAME sequence) CONTAINER &rest ARGS &key &allow-other-keys around
Generic Function: find-options QUERY CONTAINER &key INTERPRET-WILDCARDS?

Find and return a sequence of options in CONTAINER matching QUERY which can be a name with wildcard components.

Matching options can appear in any order in the returned sequence.

If CONTAINER has child containers (as can be the case for schema objects), matching options in ancestor containers (i.e. transitive children) are also found and returned.

For a description of INTERPRET-WILDCARDS?, see ‘map-matching-options’.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: find-options QUERY CONTAINER &key INTERPRET-WILDCARDS?
Method: find-options (QUERY sequence) CONTAINER &key INTERPRET-WILDCARDS? around
Generic Function: initialize SOURCE SCHEMA

Initialize SOURCE with SCHEMA. SOURCE can, for example, examine the options in SCHEMA and create corresponding internal data structures, or user-facing interfaces, help texts, etc.

Package

configuration.options.sources

Source

protocol.lisp (file)

Methods
Method: initialize (SOURCE cascade-source) SCHEMA
Source

source-cascade.lisp (file)

Method: initialize (SOURCE defaults-source) SCHEMA
Source

source-defaults.lisp (file)

Method: initialize SOURCE SCHEMA
Method: initialize SOURCE SCHEMA around
Generic Function: make-configuration SCHEMA

Make and return a configuration object the option objects in which comply to schema.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: make-configuration (SCHEMA standard-schema)
Source

schema.lisp (file)

Generic Function: make-name THING

Return a name corresponding to THING which can be a name string, a sequence of ‘name-component’s or a name.

The second return value is true if something other than THING (i.e. the result of coercing THING to a name) is returned and false if THING is returned.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: make-name (THING wildcard-name)
Source

name.lisp (file)

Method: make-name (THING sequence)
Source

name.lisp (file)

Method: make-name (THING string)
Source

name.lisp (file)

Method: make-name THING
Generic Function: make-option SCHEMA-ITEM NAME &key OPTION-CLASS OPTION-CELL-CLASS &allow-other-keys

Make and return an option object according to SCHEMA-ITEM and NAME.

The new option will be named NAME and point to a new option cell which will in turn point to SCHEMA-ITEM for type, default, documentation, etc.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: make-option (SCHEMA-ITEM standard-schema-item) (NAME sequence) &key OPTION-CLASS OPTION-CELL-CLASS
Source

schema.lisp (file)

Method: make-option SCHEMA-ITEM (NAME sequence) &rest ARGS &key &allow-other-keys around
Generic Function: make-source SPEC &key &allow-other-keys

Construct and return an object implementing the source protocol according to SPEC and the remaining keyword arguments.

For example, when SPEC is a symbol naming a provider of the ‘source’ service, the remaining keyword arguments are used as initargs.

Package

configuration.options.sources

Source

protocol.lisp (file)

Methods
Method: make-source (SPEC symbol) &rest ARGS &key
Generic Function: make-syntax SPEC &key &allow-other-keys

Construct and return an object implementing the syntax protocol according to SPEC and the remaining keyword arguments.

For example, when SPEC is a symbol naming a provider of the ‘syntax’ service, the remaining keyword arguments are used as initargs.

Package

configuration.options.sources

Source

protocol.lisp (file)

Methods
Method: make-syntax (SPEC symbol) &rest ARGS &key
Generic Function: map-matching-options FUNCTION QUERY CONTAINER &key INTERPRET-WILDCARDS? &allow-other-keys

Call FUNCTION for each option matching QUERY in CONTAINER.

See ‘map-options’ for a description of FUNCTION.

QUERY has to be a (potentially wildcard) name against which options in CONTAINER are matched.

INTERPRET-WILDCARDS? controls whether and how wild components in QUERY and in names of items in CONTAINER should be interpreted. The following values are accepted:

nil

Wildcards in neither QUERY nor CONTAINER are interpreted. That is, names only match if their components, including wildcard components are identical.

:query

Wildcards in QUERY are interpreted, allowing arbitrary name components in corresponding positions in names in CONTAINER to match.

:container

Wildcards in names in CONTAINER are interpreted, allowing arbitrary name components in corresponding positions in QUERY to match.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: map-matching-options (FUNCTION function) QUERY CONTAINER &key INTERPRET-WILDCARDS?
Method: map-matching-options FUNCTION QUERY CONTAINER &rest ARGS &key INTERPRET-WILDCARDS?
Method: map-matching-options (FUNCTION function) (QUERY sequence) CONTAINER &rest ARGS &key &allow-other-keys around
Generic Function: map-options FUNCTION CONTAINER

Call FUNCTION for each option in CONTAINER.

FUNCTION is called with at least one argument: the option. Keyword arguments may follow.

If CONTAINER is a schema object, FUNCTION is called with the following keyword arguments:

:prefix

Specifies the option name prefix of the child container in which the current option is contained (the prefix is empty for options contained in CONTAINER itself).

:container

Specifies the container in which the current option
resides (either CONTAINER or child containers thereof).

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: map-options (FUNCTION function) (CONTAINER standard-schema)
Source

schema.lisp (file)

Method: map-options (FUNCTION function) (CONTAINER list-container-mixin)
Source

mixins.lisp (file)

Method: map-options FUNCTION CONTAINER
Generic Function: merge-names LEFT RIGHT

Construct and return a new name by concatenating the components of LEFT and RIGHT.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: merge-names LEFT (RIGHT wildcard-name)
Source

name.lisp (file)

Method: merge-names (LEFT (eql nil)) RIGHT
Method: merge-names LEFT RIGHT
Generic Function: merge-values SCHEMA-ITEM VALUES

Merge the sequence of values VALUES into a single value in the appropriate way for the type of SCHEMA-ITEM and return two values: 1) nil or the merged value 2) t if the merge produced a value and nil if the merge did not produce a value.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: merge-values (SCHEMA-ITEM type-based-merging-mixin) (VALUES sequence)
Source

mixins.lisp (file)

Generic Function: merge-values-using-type SCHEMA-ITEM VALUES TYPE &key INNER-TYPE

Like ‘merge-values’ but may incorporate TYPE into the decision how to merge VALUES.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: merge-values-using-type (SCHEMA-ITEM type-based-merging-mixin) (VALUES sequence) (TYPE (eql list)) &key INNER-TYPE
Source

value-types.lisp (file)

Method: merge-values-using-type (SCHEMA-ITEM type-based-merging-mixin) (VALUES sequence) TYPE &key INNER-TYPE
Source

mixins.lisp (file)

Method: merge-values-using-type (SCHEMA-ITEM type-based-merging-mixin) (VALUES sequence) (TYPE symbol) &key INNER-TYPE
Source

mixins.lisp (file)

Method: merge-values-using-type (SCHEMA-ITEM type-based-merging-mixin) (VALUES sequence) (TYPE cons) &key INNER-TYPE
Source

mixins.lisp (file)

Generic Function: name-components NAME

Return a sequence of the components of NAME.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: name-components (WILDCARD-NAME wildcard-name)

Stores the components of the name.

Source

name.lisp (file)

Method: name-components (NAME list)
Generic Function: name-equal LEFT RIGHT &key START1 END1 START2 END2

Return non-nil when LEFT and RIGHT are equal.

In case LEFT is not equal to RIGHT, return two values: 1) nil 2) the position of the mismatch in LEFT.

START1 and END1, if supplied, select a subseqeuence of LEFT to be used in the equality test.

START2 and END2, if supplied, select a subseqeuence of RIGHT to be used in the equality test.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: name-equal LEFT RIGHT &key START1 END1 START2 END2
Generic Function: name-matches QUERY NAME &key START1 END1 START2 END2

Return non-nil when QUERY matches NAME.

This can be the case either when QUERY and NAME are equal or when QUERY contains :wild or :wild-inferiors components matching components of NAME.

START1 and END1, if supplied, select a subseqeuence of QUERY to be used in the matching computation.

START2 and END2, if supplied, select a subseqeuence of NAME to be used in the matching computation.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: name-matches (QUERY wildcard-name) NAME &key START1 END1 START2 END2
Source

name.lisp (file)

Method: name-matches QUERY NAME &key START1 END1 START2 END2
Method: name-matches QUERY NAME &key START1 END1 START2 END2 around
Generic Function: name-parse-error-text CONDITION
Package

configuration.options

Methods
Method: name-parse-error-text (CONDITION name-parse-error)
Source

conditions.lisp (file)

Generic Function: name< LEFT RIGHT

Return non-nil when LEFT is BEFORE in the following ordering: components induce a lexicographical ordering where :wild-inferiors go before :wild which in turn goes before all other components.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: name< (LEFT wildcard-name) (RIGHT sequence)
Source

name.lisp (file)

Method: name< (LEFT sequence) (RIGHT wildcard-name)
Source

name.lisp (file)

Method: name< LEFT RIGHT
Generic Function: notification-error-event CONDITION
Package

configuration.options

Methods
Method: notification-error-event (CONDITION notification-error)
Source

conditions.lisp (file)

Generic Function: notification-error-name CONDITION
Package

configuration.options

Methods
Method: notification-error-name (CONDITION notification-error)
Source

conditions.lisp (file)

Generic Function: notification-error-sink CONDITION
Package

configuration.options

Methods
Method: notification-error-sink (CONDITION notification-error)
Source

conditions.lisp (file)

Generic Function: notification-error-source CONDITION
Package

configuration.options

Methods
Method: notification-error-source (CONDITION notification-error)
Source

conditions.lisp (file)

Generic Function: notify SINK EVENT NAME VALUE &key RAW? SOURCE INDEX &allow-other-keys

SINK is notified about some change regarding the option named NAME.

EVENT can be, for example, :added, :removed, :new-value. For these three, the remaining parameters are interpreted as follows:

EVENT NAME VALUE
:added OPTION-NAME SHOULD-BE-IGNORED
:removed OPTION-NAME SHOULD-BE-IGNORED
:new-value OPTION-NAME [RAW-]NEW-VALUE

RAW? indicates whether VALUE is an unparsed string value or whether it has already been parsed.

The value of the keyword parameter SOURCE usually is the source object that produced the event, but may be nil.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: notify (SINK indexed-sink) EVENT NAME VALUE &rest ARGS &key INDEX &allow-other-keys
Source

source-cascade.lisp (file)

Method: notify (SINK standard-synchronizer) (EVENT (eql new-value)) NAME VALUE &rest ARGS &key INDEX SOURCE RAW? &allow-other-keys
Source

synchronizer.lisp (file)

Method: notify (SINK standard-synchronizer) (EVENT (eql removed)) NAME VALUE &key &allow-other-keys
Source

synchronizer.lisp (file)

Method: notify (SINK standard-synchronizer) (EVENT (eql added)) NAME VALUE &key INDEX &allow-other-keys
Source

synchronizer.lisp (file)

Method: notify SINK EVENT NAME VALUE &key SOURCE &allow-other-keys around
Generic Function: option-class SCHEMA-ITEM

Return the name of the class for options based on SCHEMA-ITEM.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: option-class (STANDARD-SCHEMA-ITEM standard-schema-item)

Stores the name of the class that should be used for
making options corresponding to this schema item.

Source

schema.lisp (file)

Generic Function: option-condition-option CONDITION
Package

configuration.options

Methods
Method: option-condition-option (CONDITION option-condition)
Source

conditions.lisp (file)

Generic Function: option-configuration OPTION

Return the configuration object containing OPTION.

Package

configuration.options

Source

protocol.lisp (file)

Generic Function: option-default OPTION &key IF-DOES-NOT-EXIST

Return two values describing the default value of OPTION: 1) nil or the default value of OPTION 2) nil if OPTION does not have a default value and t if OPTION has a default value.

IF-DOES-NOT-EXIST controls the behavior in case OPTION does not have default value:

nil

Return the two values nil, nil.

other value (but not one of the following)

Return the two values IF-DOES-NOT-EXIST, nil.

’warn, #’warn

Signal a ‘value-missing-warning’ indicating that OPTION does not have a default value and return the two values nil, nil.

’error, #’error

Signal a ‘value-missing-error’ indicating that OPTION does not have a default value.

a function

Call the function with a ‘value-missing-error’ instance indicating that OPTION does not have a default value.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: option-default (OPTION standard-option) &key IF-DOES-NOT-EXIST
Source

configuration.lisp (file)

Method: option-default (OPTION option-cell) &key IF-DOES-NOT-EXIST
Source

configuration.lisp (file)

Method: option-default (OPTION standard-schema-item) &key IF-DOES-NOT-EXIST
Source

schema.lisp (file)

Method: option-default OPTION &key IF-DOES-NOT-EXIST around
Generic Function: option-documentation OPTION

Return nil or the documentation string of OPTION.

Package

configuration.options

Source

protocol.lisp (file)

Writer

(setf option-documentation) (generic function)

Methods
Method: option-documentation (OPTION standard-option)
Source

configuration.lisp (file)

Method: option-documentation (OPTION option-cell)
Source

configuration.lisp (file)

Method: option-documentation (OPTION standard-configuration)
Source

configuration.lisp (file)

Method: option-documentation (DOCUMENTATION-MIXIN documentation-mixin)

Stores nil or the documentation string associated to the option.

Source

mixins.lisp (file)

Generic Function: (setf option-documentation) NEW-VALUE OBJECT
Package

configuration.options

Reader

option-documentation (generic function)

Methods
Method: (setf option-documentation) NEW-VALUE (DOCUMENTATION-MIXIN documentation-mixin)

Stores nil or the documentation string associated to the option.

Source

mixins.lisp (file)

Generic Function: option-name OPTION

Return the name object naming OPTION.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: option-name (NAMED-MIXIN named-mixin)

Stores the name of the option.

Source

mixins.lisp (file)

Generic Function: option-schema-item OPTION

Return the schema item corresponding to OPTION.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: option-schema-item (OPTION standard-option)
Source

configuration.lisp (file)

Method: option-schema-item (OPTION-CELL option-cell)

Stores the associated schema item which in turn
stores the type, default and documentation for the option.

Source

configuration.lisp (file)

Generic Function: option-syntax-error-type CONDITION
Package

configuration.options

Methods
Method: option-syntax-error-type (CONDITION option-syntax-error)
Source

conditions.lisp (file)

Generic Function: option-type OPTION

Return the type of OPTION. The returned type is an expression similar to a CL type.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: option-type (OPTION standard-option)
Source

configuration.lisp (file)

Method: option-type (OPTION option-cell)
Source

configuration.lisp (file)

Method: option-type (STANDARD-SCHEMA-ITEM standard-schema-item)

Stores the type of the option as an expression similar to a CL type.

Source

schema.lisp (file)

Generic Function: option-value OPTION &key IF-DOES-NOT-EXIST

Return up to three values describing the value of OPTION:
1) nil or the value of OPTION
2) nil if OPTION does not have a value and t if OPTION has a value 3) if OPTION has a value and a single source provided it, that source.

IF-DOES-NOT-EXIST controls the behavior in case OPTION does not have value:

nil

Return the two values nil, nil.

other value (but not one of the following)

Return the two values IF-DOES-NOT-EXIST, nil.

’warn, #’warn

Signal a ‘value-missing-warning’ indicating that OPTION does not have a default value and return the two values nil, nil.

’error, #’error

Signal a ‘value-missing-error’ indicating that OPTION does not have a value.

a function

Call the function with a ‘value-missing-error’ instance indicating that OPTION does not have a value.

Package

configuration.options

Source

protocol.lisp (file)

Writer

(setf option-value) (generic function)

Methods
Method: option-value (OPTION standard-option) &key IF-DOES-NOT-EXIST
Source

configuration.lisp (file)

Method: option-value (OPTION option-cell) &key IF-DOES-NOT-EXIST
Source

configuration.lisp (file)

Method: option-value OPTION &key IF-DOES-NOT-EXIST around
Generic Function: (setf option-value) NEW-VALUE OPTION &key IF-DOES-NOT-EXIST IF-INVALID

Set the current value of OPTION to NEW-VALUE.

IF-DOES-NOT-EXIST is accepted for parity with ‘option-value’.

IF-INVALID controls the behavior in case NEW-VALUE is not a valid value for OPTION. See the description of the if-invalid keyword parameter of the ‘validate-value’ generic function.

Package

configuration.options

Source

protocol.lisp (file)

Reader

option-value (generic function)

Methods
Method: (setf option-value) NEW-VALUE (OPTION standard-option) &key IF-DOES-NOT-EXIST IF-INVALID
Source

configuration.lisp (file)

Method: (setf option-value) NEW-VALUE (OPTION option-cell) &key IF-DOES-NOT-EXIST IF-INVALID after
Source

configuration.lisp (file)

Method: (setf option-value) NEW-VALUE (OPTION option-cell) &key IF-DOES-NOT-EXIST IF-INVALID
Source

configuration.lisp (file)

Method: (setf option-value) NEW-VALUE (OPTION option-cell) &key IF-DOES-NOT-EXIST IF-INVALID around
Source

configuration.lisp (file)

Generic Function: option-values OPTION

Return the (potentially empty) sequence of values from which the effective value of OPTION has been constructed via merging.

Entries are of the form

(VALUE &rest PLIST)

where VALUE is a parsed value and PLIST contains at least the property :source holding the source object from which VALUE originated. Additional properties may describe the origin of VALUE in more detail.

Package

configuration.options

Source

protocol.lisp (file)

Writer

(setf option-values) (generic function)

Methods
Method: option-values (OPTION standard-option)
Source

configuration.lisp (file)

Method: option-values (OPTION-CELL option-cell)

Stores values and additional information regarding
their origins for the option as provided by sources in order of decreasing priority. Entries are of the form

(VALUE &rest PLIST)

where VALUE is a parsed value PLIST contains at least the property :source holding the source object from which VALUE originated. Additional properties may describe the origin of VALUE in more detail.

Source

configuration.lisp (file)

Generic Function: (setf option-values) NEW-VALUE OBJECT
Package

configuration.options

Reader

option-values (generic function)

Methods
Method: (setf option-values) NEW-VALUE (OPTION standard-option)
Source

configuration.lisp (file)

Method: (setf option-values) NEW-VALUE (OPTION-CELL option-cell)

Stores values and additional information regarding
their origins for the option as provided by sources in order of decreasing priority. Entries are of the form

(VALUE &rest PLIST)

where VALUE is a parsed value PLIST contains at least the property :source holding the source object from which VALUE originated. Additional properties may describe the origin of VALUE in more detail.

Source

configuration.lisp (file)

Generic Function: options CONTAINER

Return a sequence of the options contained in CONTAINER.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: options (LIST-CONTAINER-MIXIN list-container-mixin)

Stores a sorted list of named options. The contained options are sorted according to ‘name<’.

Source

mixins.lisp (file)

Generic Function: process SOURCE SINK

Process the configuration information in SOURCE providing the resulting configuration options to SINK.

Package

configuration.options.sources

Source

protocol.lisp (file)

Methods
Method: process (SOURCE cascade-source) SINK
Source

source-cascade.lisp (file)

Method: process (SOURCE file-source) SINK
Source

source-file.lisp (file)

Method: process (SOURCE stream-source) SINK
Source

source-stream.lisp (file)

Method: process (SOURCE environment-variables-source) SINK
Source

source-environment-variables.lisp (file)

Method: process (SOURCE defaults-source) SINK
Source

source-defaults.lisp (file)

Method: process SOURCE SINK around
Generic Function: process-content SYNTAX SOURCE SINK

Process content of SOURCE assuming syntax SYNTAX and provide resulting options to SINK.

Package

configuration.options.sources

Source

protocol.lisp (file)

Generic Function: raw->value SCHEMA-ITEM RAW

Parse RAW and return a value object taking into account properties of SCHEMA-ITEM.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: raw->value (SCHEMA-ITEM type-based-conversion-mixin) RAW
Source

mixins.lisp (file)

Method: raw->value SCHEMA-ITEM RAW around
Generic Function: raw->value-using-type SCHEMA-ITEM RAW TYPE &key INNER-TYPE &allow-other-keys

Like ‘raw->value’ but may incorporate TYPE, besides SCHEMA-ITEM, into the parsing of RAW into a value object.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: raw->value-using-type (SCHEMA-ITEM type-based-conversion-mixin) RAW (TYPE (eql and)) &key INNER-TYPE
Source

value-types.lisp (file)

Method: raw->value-using-type (SCHEMA-ITEM type-based-conversion-mixin) RAW (TYPE (eql or)) &key INNER-TYPE
Source

value-types.lisp (file)

Method: raw->value-using-type (SCHEMA-ITEM type-based-conversion-mixin) (RAW string) (TYPE (eql list)) &rest ARGS &key INNER-TYPE
Source

value-types.lisp (file)

Method: raw->value-using-type (SCHEMA-ITEM type-based-conversion-mixin) (RAW list) (TYPE (eql list)) &key INNER-TYPE
Source

value-types.lisp (file)

Method: raw->value-using-type (SCHEMA-ITEM type-based-conversion-mixin) (RAW string) (TYPE (eql pathname)) &key &allow-other-keys
Source

value-types.lisp (file)

Method: raw->value-using-type (SCHEMA-ITEM type-based-conversion-mixin) (RAW string) (TYPE (eql member)) &key INNER-TYPE
Source

value-types.lisp (file)

Method: raw->value-using-type (SCHEMA-ITEM type-based-conversion-mixin) (RAW string) (TYPE (eql string)) &key INNER-TYPE
Source

value-types.lisp (file)

Method: raw->value-using-type (SCHEMA-ITEM type-based-conversion-mixin) (RAW string) (TYPE (eql integer)) &key INNER-TYPE
Source

value-types.lisp (file)

Method: raw->value-using-type (SCHEMA-ITEM type-based-conversion-mixin) (RAW string) (TYPE (eql boolean)) &key &allow-other-keys
Source

value-types.lisp (file)

Method: raw->value-using-type (SCHEMA-ITEM type-based-conversion-mixin) (RAW string) (TYPE (eql null)) &key &allow-other-keys
Source

value-types.lisp (file)

Method: raw->value-using-type (SCHEMA-ITEM type-based-conversion-mixin) RAW (TYPE symbol) &key INNER-TYPE
Source

mixins.lisp (file)

Method: raw->value-using-type (SCHEMA-ITEM type-based-conversion-mixin) RAW (TYPE cons) &key INNER-TYPE
Source

mixins.lisp (file)

Method: raw->value-using-type SCHEMA-ITEM RAW TYPE &key INNER-TYPE around
Generic Function: schema-children SCHEMA

Return a sequence of the schema items contained in SCHEMA.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: schema-children (CONTAINER standard-schema)
Source

schema.lisp (file)

Generic Function: schema-condition-schema CONDITION
Package

configuration.options.sources

Methods
Method: schema-condition-schema (CONDITION schema-condition)
Source

conditions.lisp (file)

Generic Function: schema-syntax-error-specification CONDITION
Package

configuration.options

Methods
Method: schema-syntax-error-specification (CONDITION schema-syntax-error)
Source

conditions.lisp (file)

Generic Function: sink-condition-sink CONDITION
Package

configuration.options.sources

Methods
Method: sink-condition-sink (CONDITION sink-condition)
Source

conditions.lisp (file)

Generic Function: source-condition-source CONDITION
Package

configuration.options.sources

Methods
Method: source-condition-source (CONDITION source-condition)
Source

conditions.lisp (file)

Generic Function: source-sources SOURCE

Return the inferior sources managed by SOURCE.

Package

configuration.options.sources

Source

protocol.lisp (file)

Methods
Method: source-sources (CASCADE-SOURCE cascade-source)

Stores a list of sources in order of priority.

Source

source-cascade.lisp (file)

Method: source-sources SOURCE
Generic Function: sub-configuration QUERY CONTAINER

Return a sub-configuration of CONTAINER using QUERY to select options.

QUERY should generally be a name consisting of non-empty prefix of non-wild components followed by one ‘:wild’ or ‘:wild-inferiors’ components, for example:

foo.bar.**

Queries not following this structure, such as

foo.*.bar.*

are also accepted, but can cause errors due to collisions of names
in CONTAINER after stripping the prefix:

foo.a.bar.baz -> baz
foo.b.bar.baz -> baz

The returned configuration is an instance of the class of
CONTAINER.

Options in CONTAINER matching QUERY are copied and stored in the
returned configuration as follows:

* Copied options are instances of the classes of the respective source options

* The prefix mentioned above is stripped from the names of copied options

* Copied options share the "option cell", i.e. schema link,
value storage and hooks with their respective source options.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: sub-configuration QUERY CONTAINER
Method: sub-configuration (QUERY sequence) CONTAINER around
Generic Function: synchronizer-target OBJECT
Package

configuration.options

Methods
Method: synchronizer-target (STANDARD-SYNCHRONIZER standard-synchronizer)

Stores the object into which the synchronizer should implement changes it receives via ‘notify’ calls.

Source

synchronizer.lisp (file)

Generic Function: validate-value SCHEMA-ITEM VALUE &key IF-INVALID

Determine whether VALUE is valid for SCHEMA-ITEM, signaling an error or if it is invalid.

IF-INVALID controls the behavior in case VALUE is invalid for SCHEMA-ITEM:

nil

Return nil.

’error, #’error

Signal an error which indicates VALUE being invalid.

a function

Call the function with an error object which indicates VALUE being invalid as the sole argument.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: validate-value (SCHEMA-ITEM type-based-validation-mixin) VALUE &key IF-INVALID
Source

mixins.lisp (file)

Method: validate-value SCHEMA-ITEM VALUE &key IF-INVALID around
Generic Function: validate-value-using-type SCHEMA-ITEM VALUE TYPE &key INNER-TYPE

Like ‘validate-value’ but may incorporate TYPE into the decision whether VALUE is valid for SCHEMA-ITEM.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: validate-value-using-type (SCHEMA-ITEM type-based-validation-mixin) VALUE (TYPE (eql and)) &key INNER-TYPE
Source

value-types.lisp (file)

Method: validate-value-using-type (SCHEMA-ITEM type-based-validation-mixin) VALUE (TYPE (eql or)) &key INNER-TYPE
Source

value-types.lisp (file)

Method: validate-value-using-type (SCHEMA-ITEM type-based-validation-mixin) VALUE (TYPE (eql list)) &key INNER-TYPE
Source

value-types.lisp (file)

Method: validate-value-using-type (SCHEMA-ITEM type-based-validation-mixin) VALUE TYPE &key INNER-TYPE
Source

mixins.lisp (file)

Method: validate-value-using-type (SCHEMA-ITEM type-based-validation-mixin) VALUE (TYPE symbol) &key INNER-TYPE
Source

mixins.lisp (file)

Method: validate-value-using-type (SCHEMA-ITEM type-based-validation-mixin) VALUE (TYPE cons) &key INNER-TYPE
Source

mixins.lisp (file)

Generic Function: value OPTION-OR-NAME &key CONFIGURATION IF-DOES-NOT-EXIST IF-NO-VALUE

Return the value of OPTION-OR-NAME in CONFIGURATION.

OPTION-OR-NAME is either an option object or an option name designating an option in CONFIGURATION.

If CONFIGURATION is not supplied, the value of *CONFIGURATION* is used. An error is signaled if CONFIGURATION is null.

IF-DOES-NOT-EXIST controls the behavior in case OPTION-OR-NAME is an option name (not an option object) and does not designate an option in CONFIGURATION. For a description of return values, signaled conditions and IF-DOES-NOT-EXIST, see ‘find-option’.

IF-NO-VALUE controls the behavior in case OPTION-OR-NAME does not have a value. For a description of returns values, signaled conditions and IF-NO-VALUE, see IF-DOES-NOT-EXIST in the description of ‘option-value’.

Package

configuration.options

Source

protocol.lisp (file)

Writer

(setf value) (generic function)

Methods
Method: value OPTION-OR-NAME &key CONFIGURATION IF-DOES-NOT-EXIST IF-NO-VALUE
Method: value (OPTION-OR-NAME sequence) &key CONFIGURATION IF-DOES-NOT-EXIST IF-NO-VALUE around
Generic Function: (setf value) NEW-VALUE OPTION-OR-NAME &key CONFIGURATION IF-DOES-NOT-EXIST IF-NO-VALUE

Set value of OPTION-OR-NAME in CONFIGURATION to NEW-VALUE.

OPTION-OR-NAME is either an option object or an option name designating an option in CONFIGURATION.

If CONFIGURATION is not supplied, the value of *CONFIGURATION* is used. An error is signaled if CONFIGURATION is null.

IF-DOES-NOT-EXIST controls the behavior in case OPTION-OR-NAME is an option name (not an option object) and does not designate an option in CONFIGURATION. For a description of return values, signaled conditions and IF-DOES-NOT-EXIST, see ‘find-option’.

IF-NO-VALUE is accepted for parity with ‘value’.

Package

configuration.options

Source

protocol.lisp (file)

Reader

value (generic function)

Methods
Method: (setf value) NEW-VALUE OPTION-OR-NAME &key CONFIGURATION IF-DOES-NOT-EXIST IF-NO-VALUE
Method: (setf value) NEW-VALUE (OPTION-OR-NAME sequence) &key CONFIGURATION IF-DOES-NOT-EXIST IF-NO-VALUE around
Generic Function: value->string SCHEMA-ITEM VALUE

Return a string representation of VALUE taking into account properties of SCHEMA-ITEM.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: value->string (SCHEMA-ITEM type-based-conversion-mixin) VALUE
Source

mixins.lisp (file)

Generic Function: value->string-using-type SCHEMA-ITEM VALUE TYPE &key INNER-TYPE &allow-other-keys

Like ‘value->string’ but may incorporate TYPE, besides SCHEMA-ITEM, into the conversion of VALUE into a string representation.

Package

configuration.options

Source

protocol.lisp (file)

Methods
Method: value->string-using-type (SCHEMA-ITEM type-based-conversion-mixin) VALUE (TYPE (eql and)) &key INNER-TYPE
Source

value-types.lisp (file)

Method: value->string-using-type (SCHEMA-ITEM type-based-conversion-mixin) VALUE (TYPE (eql or)) &key INNER-TYPE
Source

value-types.lisp (file)

Method: value->string-using-type (SCHEMA-ITEM type-based-conversion-mixin) (VALUE list) (TYPE (eql list)) &key INNER-TYPE
Source

value-types.lisp (file)

Method: value->string-using-type (SCHEMA-ITEM type-based-conversion-mixin) (VALUE pathname) (TYPE (eql pathname)) &key &allow-other-keys
Source

value-types.lisp (file)

Method: value->string-using-type (SCHEMA-ITEM type-based-conversion-mixin) (VALUE symbol) (TYPE (eql member)) &key &allow-other-keys
Source

value-types.lisp (file)

Method: value->string-using-type (SCHEMA-ITEM type-based-conversion-mixin) (VALUE string) (TYPE (eql string)) &key &allow-other-keys
Source

value-types.lisp (file)

Method: value->string-using-type (SCHEMA-ITEM type-based-conversion-mixin) (VALUE integer) (TYPE (eql integer)) &key &allow-other-keys
Source

value-types.lisp (file)

Method: value->string-using-type (SCHEMA-ITEM type-based-conversion-mixin) VALUE (TYPE (eql boolean)) &key &allow-other-keys
Source

value-types.lisp (file)

Method: value->string-using-type (SCHEMA-ITEM type-based-conversion-mixin) VALUE (TYPE (eql null)) &key &allow-other-keys
Source

value-types.lisp (file)

Method: value->string-using-type (SCHEMA-ITEM type-based-conversion-mixin) VALUE (TYPE symbol) &key INNER-TYPE
Source

mixins.lisp (file)

Method: value->string-using-type (SCHEMA-ITEM type-based-conversion-mixin) VALUE (TYPE cons) &key INNER-TYPE
Source

mixins.lisp (file)

Generic Function: value-condition-value CONDITION
Package

configuration.options

Methods
Method: value-condition-value (CONDITION value-condition)
Source

conditions.lisp (file)

Generic Function: value-missing-condition-which CONDITION
Package

configuration.options

Methods
Method: value-missing-condition-which (CONDITION value-missing-condition)
Source

conditions.lisp (file)


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

6.1.6 Conditions

Condition: binding-condition ()

Instance of subclasses of this condition class are signaled in situations involving a named binding in a container.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses

condition (condition)

Direct subclasses
Direct methods
Direct slots
Slot: name

Stores the name of the item which could not be found.

Initargs

:name

Readers

binding-condition-name (generic function)

Slot: container

Stores the container object in which the requested item could not be found.

Initargs

:container

Readers

binding-condition-container (generic function)

Direct Default Initargs
InitargValue
:container(more-conditions:missing-required-initarg (quote configuration.options:binding-condition) :container)
:name(more-conditions:missing-required-initarg (quote configuration.options:binding-condition) :name)
Condition: binding-exists-condition ()

Instances of subclasses of this condition class are signaled when an attempt is made to store an item in a container under a name for which an item is already stored.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses

binding-condition (condition)

Direct subclasses
Direct methods

binding-exists-condition-existing (method)

Direct slots
Slot: existing

Stores the object already stored under the name in question.

Initargs

:existing

Readers

binding-exists-condition-existing (generic function)

Direct Default Initargs
InitargValue
:existing(more-conditions:missing-required-initarg (quote configuration.options:binding-exists-condition) :existing)
Condition: binding-missing-condition ()

Instances of subclasses of this condition class are signaled when a requested item object cannot be found in a container.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses

binding-condition (condition)

Direct subclasses
Condition: child-exists-error ()

This error is signaled when an attempt is made to store a child in a container under a name for which a child is already stored.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses
Condition: child-exists-warning ()

This warning is signaled when an attempt is made to store a child in a container under a name for which a child is already stored.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses
Condition: child-missing-error ()

This error is signaled when a requested child cannot be found in a container.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses
Condition: child-missing-warning ()

This warning is signaled when a requested child cannot be found in a container.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses
Condition: initialization-error ()

This error is signaled when initializing a configuration source fails.

Package

configuration.options.sources

Source

conditions.lisp (file)

Direct superclasses
Condition: name-parse-error ()

This error is signaled when a given string cannot be parsed as an option name.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses

parse-error (condition)

Direct methods

name-parse-error-text (method)

Direct slots
Slot: text

Stores the string which could not be parsed as an option name.

Initargs

:text

Readers

name-parse-error-text (generic function)

Condition: notification-error ()

This error is signaled when an error is encountered during notification of a sink of an event originating from a source.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses
  • chainable-condition (condition)
  • value-condition (condition)
  • error (condition)
Direct methods
Direct slots
Slot: sink

Stores the sink which was being notified when the error was encountered.

Initargs

:sink

Readers

notification-error-sink (generic function)

Slot: event

Stores the event of which the was being notified when the error was encountered

Initargs

:event

Readers

notification-error-event (generic function)

Slot: name

Stores the name of the option that was the subject of the notification during which the error was encountered.

Initargs

:name

Readers

notification-error-name (generic function)

Slot: source

Stores the source from which the notification originated.

Initargs

:source

Readers

notification-error-source (generic function)

Condition: option-exists-error ()

This error is signaled when an attempt is made to store a option in a container under a name for which a option is already stored.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses
Condition: option-exists-warning ()

This warning is signaled when an attempt is made to store a option in a container under a name for which a option is already stored.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses
Condition: option-missing-error ()

This error is signaled when a requested option cannot be found in a container.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses
Condition: option-missing-warning ()

This warning is signaled when a requested option cannot be found in a container.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses
Condition: option-syntax-error ()

This error is signaled when a given string cannot be parsed as a value of a particular option.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses

option-value-error (condition)

Direct methods

option-syntax-error-type (method)

Direct slots
Slot: type

Stores the type that was used in the failed parsing attempt.

Initargs

:type

Initform

(quote nil)

Readers

option-syntax-error-type (generic function)

Condition: option-value-error ()

This error and its subclasses is signaled when an error regarding an option value is encountered.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses
Direct subclasses

option-syntax-error (condition)

Condition: processing-error ()

This error is signaled when processing a source in order to provide options to a sink fails.

Package

configuration.options.sources

Source

conditions.lisp (file)

Direct superclasses
Condition: schema-condition ()

Instances of subclasses of this condition are signaled when an unexpected condition is encountered during an operation involving a schema.

Package

configuration.options.sources

Source

conditions.lisp (file)

Direct superclasses

condition (condition)

Direct subclasses

initialization-error (condition)

Direct methods

schema-condition-schema (method)

Direct slots
Slot: schema

Stores the schema involved in the operation for which the condition is signaled.

Initargs

:schema

Readers

schema-condition-schema (generic function)

Direct Default Initargs
InitargValue
:schema(more-conditions:missing-required-initarg (quote configuration.options.sources:schema-condition) :schema)
Condition: schema-syntax-error ()

This error is signaled when a schema specification is syntactically incorrect.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses

error (condition)

Direct methods

schema-syntax-error-specification (method)

Direct slots
Slot: specification

Stores the offending specification.

Initargs

:specification

Readers

schema-syntax-error-specification (generic function)

Direct Default Initargs
InitargValue
:specification(more-conditions:missing-required-initarg (quote configuration.options:schema-syntax-error) :specification)
Condition: sink-condition ()

Instances of subclasses of this condition are signaled when an unexpected condition is encountered during an operation involving a sink.

Package

configuration.options.sources

Source

conditions.lisp (file)

Direct superclasses

condition (condition)

Direct subclasses

processing-error (condition)

Direct methods

sink-condition-sink (method)

Direct slots
Slot: sink

Stores the sink involved in the operation for which the condition is signaled.

Initargs

:sink

Readers

sink-condition-sink (generic function)

Direct Default Initargs
InitargValue
:sink(more-conditions:missing-required-initarg (quote configuration.options.sources:sink-condition) :sink)
Condition: source-condition ()

Instances of subclasses of this condition are signaled when an unexpected condition is encountered during an operation involving a source.

Package

configuration.options.sources

Source

conditions.lisp (file)

Direct superclasses

condition (condition)

Direct subclasses
Direct methods

source-condition-source (method)

Direct slots
Slot: source

Stores the source involved in the operation for which the condition is signaled.

Initargs

:source

Readers

source-condition-source (generic function)

Direct Default Initargs
InitargValue
:source(more-conditions:missing-required-initarg (quote configuration.options.sources:source-condition) :source)
Condition: value-missing-condition ()

Instances of subclasses of this condition class are signaled when an option value is requested which does not exist.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses

option-condition (condition)

Direct subclasses
Direct methods

value-missing-condition-which (method)

Direct slots
Slot: which

Stores a symbol describing the option value which was requested but did not exist.

Initargs

:which

Initform

(quote :value)

Readers

value-missing-condition-which (generic function)

Condition: value-missing-error ()
Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses
Condition: value-missing-warning ()
Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses

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

6.1.7 Classes

Class: standard-configuration ()

Instances of this class store collections of named options.

Package

configuration.options

Source

configuration.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: schema

Stores the schema object associated to the configuration object.

Initargs

:schema

Readers

configuration-schema (generic function)

Direct Default Initargs
InitargValue
:schema(more-conditions:missing-required-initarg (quote configuration.options:standard-configuration) :schema)
Class: standard-option ()

Instances of this class associate an option name to an schema item and potentially an option value.

Package

configuration.options

Source

configuration.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: cell

Stores the cell which in turn stores the associated schema item and can store the actual value of the option.

Initargs

:cell

Readers

option-%cell (generic function)

Direct Default Initargs
InitargValue
:cell(more-conditions:missing-required-initarg (quote configuration.options:standard-option) :cell)
Class: standard-schema ()

Instances of this class store named schema items which describe option names, option types and other properties. In addition, schema instances can contain child schemas.

Package

configuration.options

Source

schema.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: children

Stores named child schemas. Elements are of the form

(NAME . CHILD-SCHEMA)

where NAME is a wild name.

Type

list

Initform

(quote nil)

Readers
Writers

(setf %children) (generic function)

Class: standard-schema-item ()

Instances of this class associate an name or name pattern to a type and optionally a default value.

Package

configuration.options

Source

schema.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: type

Stores the type of the option as an expression similar to a CL type.

Initargs

:type

Readers

option-type (generic function)

Slot: default

Stores a function returning the default value of the
schema item.

Is unbound when the schema item does not have a default value.

Type

function

Readers

option-%default (generic function)

Writers

(setf option-%default) (generic function)

Slot: option-class

Stores the name of the class that should be used for
making options corresponding to this schema item.

Type

symbol

Initargs

:option-class

Readers

option-class (generic function)

Direct Default Initargs
InitargValue
:type(more-conditions:missing-required-initarg (quote configuration.options:standard-schema-item) (quote type))
:option-class(quote configuration.options:standard-option)
Class: standard-synchronizer ()

Instances of this class are notified of configuration changes via calls of ‘notify’ generic function and implement these changes in "target" objects such as ‘standard-configuration’ instances.

Note: this synchronizer is not thread-safe.

Package

configuration.options

Source

synchronizer.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: target

Stores the object into which the synchronizer should implement changes it receives via ‘notify’ calls.

Initargs

:target

Readers

synchronizer-target (generic function)

Direct Default Initargs
InitargValue
:target(more-conditions:missing-required-initarg (quote configuration.options:standard-synchronizer) :target)
Class: wildcard-name ()

Instances of this class represent names which contain at least one wild component.

Package

configuration.options

Source

name.lisp (file)

Direct superclasses
  • sequence (class)
  • standard-object (class)
Direct methods
Direct slots
Slot: components

Stores the components of the name.

Type

list

Initargs

:components

Readers

name-components (generic function)

Direct Default Initargs
InitargValue
:components(more-conditions:missing-required-initarg (quote configuration.options:wildcard-name) :components)

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

6.1.8 Types

Type: name-component ()

Valid components of an option name.

Package

configuration.options

Source

types.lisp (file)

Type: non-wild-name-component ()

Valid components of a non-wild option name.

Package

configuration.options

Source

types.lisp (file)

Type: wild-name-component ()

Wild components of an option name (like in pathnames).

Package

configuration.options

Source

types.lisp (file)


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

6.2 Internal definitions


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

6.2.1 Constants

Constant: +config-file-pwd-placeholder+
Package

configuration.options.sources

Source

configuration-files.lisp (file)

Constant: +config-file-system-placeholder+
Package

configuration.options.sources

Source

configuration-files.lisp (file)

Constant: +config-file-user-placeholder+
Package

configuration.options.sources

Source

configuration-files.lisp (file)

Constant: +config-files-variable-suffix+
Package

configuration.options.sources

Source

configuration-files.lisp (file)

Constant: +no-value+

This object is used to indicate that a value cell is not occupied.

Package

configuration.options

Source

variables.lisp (file)


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

6.2.2 Special variables

Special Variable: *debug-index*
Package

configuration.options.sources

Source

debug.lisp (file)

Special Variable: *default-configuration-files*

List of configuration file names in order of decreasing priority.

Package

configuration.options.sources

Source

configuration-files.lisp (file)

Special Variable: *level*
Package

configuration.options.debug

Source

debug.lisp (file)

Special Variable: *parse-wild-allowed*

Controls whether "*" is accepted and interpreted as :wild component when parsing names.

Package

configuration.options

Source

name.lisp (file)

Special Variable: *parse-wild-inferiors-allowed*

Controls whether "**" is accepted and interpreted as :wild-inferiors component when parsing names.

Package

configuration.options

Source

name.lisp (file)

Special Variable: *stream*
Package

configuration.options.debug

Source

debug.lisp (file)


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

6.2.3 Macros

Macro: define-dispatch-methods NAME (CLASS VALUE-PARAMETER VALUE-SPECIALIZER)
Package

configuration.options

Source

mixins.lisp (file)

Macro: if-name VAR THEN ELSE
Package

configuration.options

Source

protocol.lisp (file)

Macro: with-source-debug (FORMAT-CONTROL &rest FORMAT-ARGUMENTS) &body FORMS
Package

configuration.options.sources

Source

debug.lisp (file)


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

6.2.4 Functions

Function: %every-element-name-component? THING
Package

configuration.options

Source

types.lisp (file)

Function: %has-wild-component? THING
Package

configuration.options

Source

types.lisp (file)

Function: %make-option-value OPTION &optional IF-DOES-NOT-EXIST
Package

configuration.options

Source

let-plus.lisp (file)

Function: %maybe-check-detailed-type VALUE TYPE INNER-TYPE FORMAT-CONTROL
Package

configuration.options

Source

value-types.lisp (file)

Function: %parse-value-binding SPEC
Package

configuration.options

Source

let-plus.lisp (file)

Function: %update-value OPTION SCHEMA-ITEM VALUES
Package

configuration.options

Source

synchronizer.lisp (file)

Function: call-with-source-debug THUNK FORMAT-CONTROL FORMAT-ARGUMENTS
Package

configuration.options.sources

Source

debug.lisp (file)

Function: config-files-variable-name PREFIX
Package

configuration.options.sources

Source

configuration-files.lisp (file)

Function: config-files-variable-value PREFIX
Package

configuration.options.sources

Source

configuration-files.lisp (file)

Function: copy-indexed-sink INSTANCE
Package

configuration.options.sources

Source

source-cascade.lisp (file)

Function: environment-variable-namify STRING
Package

configuration.options.sources

Source

source-cascade.lisp (file)

Function: handler-of SYNCHRONIZER
Package

configuration.options

Source

synchronizer.lisp (file)

Function: ignore-meta-configuration-variables FUNCTION
Package

configuration.options.sources

Source

source-cascade.lisp (file)

Function: indexed-sink-index INSTANCE
Package

configuration.options.sources

Source

source-cascade.lisp (file)

Function: indexed-sink-p OBJECT
Package

configuration.options.sources

Source

source-cascade.lisp (file)

Function: indexed-sink-sink INSTANCE
Package

configuration.options.sources

Source

source-cascade.lisp (file)

Function: make-environment-variable-name->option-name &key PREFIX
Package

configuration.options.sources

Source

source-environment-variables.lisp (file)

Function: make-indexed-sink INDEX SINK
Package

configuration.options.sources

Source

source-cascade.lisp (file)

Function: map-query-alignments FUNCTION QUERY START1 END1 NAME START2 END2
Package

configuration.options

Source

name.lisp (file)

Function: print-documentation STREAM DOCUMENTATION &optional COLON? AT?

‘pprint-fill’ the words in DOCUMENTATION onto STREAM.

Package

configuration.options

Source

util.lisp (file)

Function: system-configuration-directory &key PREFIX
Package

configuration.options.sources

Source

configuration-files.lisp (file)

Function: typexpand-1 TYPE-SPECIFIER
Package

configuration.options

Source

util.lisp (file)

Function: typexpand-1-unless-builtin TYPE-SPECIFIER
Package

configuration.options

Source

util.lisp (file)

Function: user-configuration-directory &key USER-HOMEDIR
Package

configuration.options.sources

Source

configuration-files.lisp (file)


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

6.2.5 Generic functions

Generic Function: %children OBJECT
Generic Function: (setf %children) NEW-VALUE OBJECT
Package

configuration.options

Methods
Method: %children (STANDARD-SCHEMA standard-schema)
Method: (setf %children) NEW-VALUE (STANDARD-SCHEMA standard-schema)

Stores named child schemas. Elements are of the form

(NAME . CHILD-SCHEMA)

where NAME is a wild name.

Source

schema.lisp (file)

Generic Function: %options OBJECT
Generic Function: (setf %options) NEW-VALUE OBJECT
Package

configuration.options

Methods
Method: %options (LIST-CONTAINER-MIXIN list-container-mixin)
Method: (setf %options) NEW-VALUE (LIST-CONTAINER-MIXIN list-container-mixin)

Stores a sorted list of named options. The contained options are sorted according to ‘name<’.

Source

mixins.lisp (file)

Generic Function: option-%cell OBJECT
Package

configuration.options

Methods
Method: option-%cell (STANDARD-OPTION standard-option)

Stores the cell which in turn stores the associated schema item and can store the actual value of the option.

Source

configuration.lisp (file)

Generic Function: option-%default OBJECT
Generic Function: (setf option-%default) NEW-VALUE OBJECT
Package

configuration.options

Methods
Method: option-%default (STANDARD-SCHEMA-ITEM standard-schema-item)
Method: (setf option-%default) NEW-VALUE (STANDARD-SCHEMA-ITEM standard-schema-item)

Stores a function returning the default value of the
schema item.

Is unbound when the schema item does not have a default value.

Source

schema.lisp (file)

Method: (setf option-%default) (NEW-VALUE function) (OPTION standard-schema-item) before
Source

schema.lisp (file)

Method: (setf option-%default) NEW-VALUE (OPTION standard-schema-item) around
Source

schema.lisp (file)

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

configuration.options

Methods
Method: (setf option-%name) NEW-VALUE (NAMED-MIXIN named-mixin)

Stores the name of the option.

Source

mixins.lisp (file)

Generic Function: option-%value OBJECT
Generic Function: (setf option-%value) NEW-VALUE OBJECT
Package

configuration.options

Methods
Method: option-%value (OPTION-CELL option-cell)
Method: (setf option-%value) NEW-VALUE (OPTION-CELL option-cell)

Stores the value of the option cell.

Is unbound when the option cell does not have a value.

Source

configuration.lisp (file)

Generic Function: schema-children/alist OBJECT
Package

configuration.options

Methods
Method: schema-children/alist (STANDARD-SCHEMA standard-schema)

Stores named child schemas. Elements are of the form

(NAME . CHILD-SCHEMA)

where NAME is a wild name.

Source

schema.lisp (file)

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

configuration.options.sources

Methods
Method: source-%name-mapping (ENVIRONMENT-VARIABLES-SOURCE environment-variables-source)
Method: (setf source-%name-mapping) NEW-VALUE (ENVIRONMENT-VARIABLES-SOURCE environment-variables-source)

Stores a function that maps environment variable names to option names.

Source

source-environment-variables.lisp (file)

Generic Function: source-%pathname OBJECT
Generic Function: (setf source-%pathname) NEW-VALUE OBJECT
Package

configuration.options.sources

Methods
Method: source-%pathname (FILE-SOURCE file-source)
Method: (setf source-%pathname) NEW-VALUE (FILE-SOURCE file-source)

Stores the pathname of the file from which
configuration options should be read.

Source

source-file.lisp (file)

Generic Function: source-%schema OBJECT
Generic Function: (setf source-%schema) NEW-VALUE OBJECT
Package

configuration.options.sources

Methods
Method: source-%schema (DEFAULTS-SOURCE defaults-source)

automatically generated reader method

Source

source-defaults.lisp (file)

Method: (setf source-%schema) NEW-VALUE (DEFAULTS-SOURCE defaults-source)

automatically generated writer method

Source

source-defaults.lisp (file)

Generic Function: source-%sources OBJECT
Generic Function: (setf source-%sources) NEW-VALUE OBJECT
Package

configuration.options.sources

Methods
Method: source-%sources (CASCADE-SOURCE cascade-source)
Method: (setf source-%sources) NEW-VALUE (CASCADE-SOURCE cascade-source)

Stores a list of sources in order of priority.

Source

source-cascade.lisp (file)

Generic Function: source-%stream OBJECT
Generic Function: (setf source-%stream) NEW-VALUE OBJECT
Package

configuration.options.sources

Methods
Method: source-%stream (STREAM-SOURCE stream-source)
Method: (setf source-%stream) NEW-VALUE (STREAM-SOURCE stream-source)

Stores the stream from which the source reads when processing.

Source

source-stream.lisp (file)

Generic Function: source-%syntax OBJECT
Generic Function: (setf source-%syntax) NEW-VALUE OBJECT
Package

configuration.options.sources

Methods
Method: source-%syntax (STREAM-SOURCE stream-source)
Method: (setf source-%syntax) NEW-VALUE (STREAM-SOURCE stream-source)

Stores the syntax object which should be used to parse the contents of the processed stream.

Source

source-stream.lisp (file)

Generic Function: source-description OBJECT
Package

configuration.options.sources

Methods
Method: source-description (FILE-SOURCE file-source)

A description of the role the file source plays in the configuration scheme.

Source

source-file.lisp (file)

Generic Function: source-element-type OBJECT
Package

configuration.options.sources

Methods
Method: source-element-type (FILE-SOURCE file-source)

Stores the desired element-type of the stream created for the source.

Source

source-file.lisp (file)

Generic Function: source-if-does-not-exist OBJECT
Package

configuration.options.sources

Methods
Method: source-if-does-not-exist (FILE-SOURCE file-source)

Stores the behavior in case the specified file does not exist.

Source

source-file.lisp (file)

Generic Function: source-name-mapping OBJECT
Package

configuration.options.sources

Methods
Method: source-name-mapping (ENVIRONMENT-VARIABLES-SOURCE environment-variables-source)

Stores a function that maps environment variable names to option names.

Source

source-environment-variables.lisp (file)

Generic Function: source-pathname OBJECT
Package

configuration.options.sources

Methods
Method: source-pathname (FILE-SOURCE file-source)

Stores the pathname of the file from which
configuration options should be read.

Source

source-file.lisp (file)

Generic Function: source-pattern OBJECT
Package

configuration.options.sources

Methods
Method: source-pattern (DIRECTORY-SOURCE directory-source)

A (wild) pathname or pathname designator which will be used to collect files for the source.

Source

source-cascade.lisp (file)

Generic Function: source-stream OBJECT
Package

configuration.options.sources

Methods
Method: source-stream (STREAM-SOURCE stream-source)

Stores the stream from which the source reads when processing.

Source

source-stream.lisp (file)

Generic Function: source-syntax OBJECT
Package

configuration.options.sources

Methods
Method: source-syntax (STREAM-SOURCE stream-source)

Stores the syntax object which should be used to parse the contents of the processed stream.

Source

source-stream.lisp (file)

Generic Function: synchronizer-handler-synchronizer OBJECT
Package

configuration.options

Methods
Method: synchronizer-handler-synchronizer (SYNCHRONIZER-HANDLER synchronizer-handler)

Stores the synchronizer which created this handler.

Source

synchronizer.lisp (file)


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

6.2.6 Conditions

Condition: option-condition ()

Subclasses of this condition class are signaled when a problem involving an option is encountered.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses

condition (condition)

Direct subclasses
Direct methods

option-condition-option (method)

Direct slots
Slot: option

Stores the involved option or its name.

Initargs

:option

Readers

option-condition-option (generic function)

Direct Default Initargs
InitargValue
:option(more-conditions:missing-required-initarg (quote configuration.options::option-condition) :option)
Condition: value-condition ()

Subclasses of this condition class are signaled when a problem regarding an option value is encountered.

Package

configuration.options

Source

conditions.lisp (file)

Direct superclasses

condition (condition)

Direct subclasses
Direct methods

value-condition-value (method)

Direct slots
Slot: value

Stores the problematic option value.

Initargs

:value

Readers

value-condition-value (generic function)

Direct Default Initargs
InitargValue
:value(more-conditions:missing-required-initarg (quote configuration.options::value-condition) :value)

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

6.2.7 Structures

Structure: indexed-sink ()
Package

configuration.options.sources

Source

source-cascade.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

notify (method)

Direct slots
Slot: index
Type

alexandria.0.dev:non-negative-integer

Initform

(more-conditions:missing-required-initarg (quote configuration.options.sources::indexed-sink) :index)

Readers

indexed-sink-index (function)

Writers

(setf indexed-sink-index) (function)

Slot: sink
Initform

(more-conditions:missing-required-initarg (quote configuration.options.sources::indexed-sink) :sink)

Readers

indexed-sink-sink (function)

Writers

(setf indexed-sink-sink) (function)


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

6.2.8 Classes

Class: cascade-source ()

This source organizes a set of sources into a prioritized cascade.

Option values from sources with higher priority are shadow or are combined with option values from sources with lower priority.

When subordinate sources are themselves cascades, their priorities are integrated into the priorities of the containing cascade.

Package

configuration.options.sources

Source

source-cascade.lisp (file)

Direct superclasses

print-items-mixin (class)

Direct subclasses
Direct methods
Direct slots
Slot: sources

Stores a list of sources in order of priority.

Type

list

Initargs

:sources

Initform

(quote nil)

Readers
Writers

(setf source-%sources) (generic function)

Class: common-cascade-source ()

This source implements a typical cascade for commandline programs.

The cascade consists of the following sources:
1. Commandline options
2. Environment variables
3. Configuration files
1. ./BASENAME.TYPE
2. ~/.config/BASENAME.TYPE
3. PREFIX/etc/BASENAME.TYPE
4. Default values

where TYPE defaults to "conf" and PREFIX defaults to "/".

Package

configuration.options.sources

Source

source-cascade.lisp (file)

Direct superclasses

cascade-source (class)

Direct methods

shared-initialize (method)

Direct Default Initargs
InitargValue
:basename(more-conditions:missing-required-initarg (quote configuration.options.sources::common-cascade-source) :basename)
Class: config-file-cascade-source ()

This source implements a cascade of file-based sources.

Names of configuration files are derived from a given base name.

The following initargs are accepted:

:prefix PREFIX

"/etc/" and CONFIG-FILE are appended to this prefix to form the name of the system-wide (actually prefix-wide) configuration file. Defaults to "/". Incompatible with :paths.

:paths PATHS

A list of directories containing configuration files, each of which is merged with the value of CONFIG-FILE to produce a configuration file name. Incompatible with :prefix.

:config-file CONFIG-FILE

A configuration file basename (without directory) with is merged with each element of PATHS to produce configuration file names.

:sources SOURCES

This initarg is accepted to maintain the protocol of the ‘cascade-source’ superclass, but is incompatible with all other initargs.

Package

configuration.options.sources

Source

source-cascade.lisp (file)

Direct superclasses

cascade-source (class)

Direct methods
  • print-items (method)
  • shared-initialize (method)
Class: defaults-source ()

This source assigns default values to options.

Package

configuration.options.sources

Source

source-defaults.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: schema
Readers

source-%schema (generic function)

Writers

(setf source-%schema) (generic function)

Class: describe-via-map-options-mixin ()

This class is intended to be mixed into option container classes that need a method on ‘describe-opbject’.

Package

configuration.options

Source

mixins.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods

describe-object (method)

Class: directory-source ()

Collects config files and creates corresponding subordinate sources.

The following initargs are accepted:

:pattern PATTERN

A (wild) pathname or pathname designator which will be used to collect files for the source.

:ignore FUNCTION-OF-ONE-ARGUMENT

A function or function designator that should be called on collected candidate files to decide whether they should be used or ignored.

:compare FUNCTION-OF-TWO-ARGUMENTS

A function or function designator that should be used to sort collected files and thereby determine a processing order.

Package

configuration.options.sources

Source

source-cascade.lisp (file)

Direct superclasses

cascade-source (class)

Direct methods
  • print-items (method)
  • shared-initialize (method)
  • source-pattern (method)
Direct slots
Slot: pattern

A (wild) pathname or pathname designator which will be used to collect files for the source.

Type

(or string pathname)

Initargs

:pattern

Readers

source-pattern (generic function)

Direct Default Initargs
InitargValue
:pattern(more-conditions:missing-required-initarg (quote configuration.options.sources::directory-source) :pattern)
:ignore(load-time-value (alexandria.0.dev:curry (function alexandria.0.dev:starts-with) #\full_stop) t)
:compare(load-time-value (lambda (configuration.options.sources::x configuration.options.sources::y) (string< (pathname-name configuration.options.sources::x) (pathname-name configuration.options.sources::y))) t)
Class: documentation-mixin ()

This class is intended to be mixed into all classes instances of which can have an associated documentation string.

Package

configuration.options

Source

mixins.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: documentation

Stores nil or the documentation string associated to the option.

Type

(or null string)

Initargs

:documentation

Readers

option-documentation (generic function)

Writers

(setf option-documentation) (generic function)

Class: environment-variables-source ()

This source reads values of environment variables.

Package

configuration.options.sources

Source

source-environment-variables.lisp (file)

Direct superclasses

print-items-mixin (class)

Direct methods
Direct slots
Slot: name-mapping

Stores a function that maps environment variable names to option names.

Type

function

Initargs

:name-mapping

Initform

(configuration.options.sources::make-environment-variable-name->option-name)

Readers
Writers

(setf source-%name-mapping) (generic function)

Class: event-hook-mixin ()

This class is intended to be mixed into classes which have to emit or relay events using the event hooks mechanism.

Package

configuration.options

Source

mixins.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods

event-hook (method)

Direct slots
Slot: event-hook

Stores the handlers of the event hook of the object.

Type

list

Initform

(quote nil)

Class: file-source ()

This source reads configuration data from files.

Package

configuration.options.sources

Source

source-file.lisp (file)

Direct superclasses

stream-source (class)

Direct methods
Direct slots
Slot: pathname

Stores the pathname of the file from which
configuration options should be read.

Type

pathname

Readers
Writers

(setf source-%pathname) (generic function)

Slot: element-type

Stores the desired element-type of the stream created for the source.

Initargs

:element-type

Initform

(quote character)

Readers

source-element-type (generic function)

Slot: if-does-not-exist

Stores the behavior in case the specified file does not exist.

Initargs

:if-does-not-exist

Initform

:error

Readers

source-if-does-not-exist (generic function)

Slot: description

A description of the role the file source plays in the configuration scheme.

Type

(or null string)

Initargs

:description

Readers

source-description (generic function)

Direct Default Initargs
InitargValue
:stream(load-time-value (make-string-input-stream "") t)
:pathname(more-conditions:missing-required-initarg (quote configuration.options.sources::file-source) :pathname)
Class: list-container-mixin ()

This class is intended to be mixed into classes which act as a container of options.

Package

configuration.options

Source

mixins.lisp (file)

Direct superclasses

event-hook-mixin (class)

Direct subclasses
Direct methods
Direct slots
Slot: options

Stores a sorted list of named options. The contained options are sorted according to ‘name<’.

Type

list

Readers
Writers

(setf %options) (generic function)

Class: named-mixin ()

This class is intended to be mixed into classes instances of which have an associated name.

Package

configuration.options

Source

mixins.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: name

Stores the name of the option.

Readers

option-name (generic function)

Writers

(setf option-%name) (generic function)

Direct Default Initargs
InitargValue
:name(more-conditions:missing-required-initarg (quote configuration.options::named-mixin) :name)
Class: option-cell ()

Instances of this class represent all aspects of options but their name.

Options point to cells for value storage and, transitively, the associated schema-item. Multiple options can point to one ‘option-cell’ instance.

Package

configuration.options

Source

configuration.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: schema-item

Stores the associated schema item which in turn
stores the type, default and documentation for the option.

Initargs

:schema-item

Readers

option-schema-item (generic function)

Slot: value

Stores the value of the option cell.

Is unbound when the option cell does not have a value.

Readers

option-%value (generic function)

Writers

(setf option-%value) (generic function)

Slot: values

Stores values and additional information regarding
their origins for the option as provided by sources in order of decreasing priority. Entries are of the form

(VALUE &rest PLIST)

where VALUE is a parsed value PLIST contains at least the property :source holding the source object from which VALUE originated. Additional properties may describe the origin of VALUE in more detail.

Type

vector

Initform

(make-array 0)

Readers

option-values (generic function)

Writers

(setf option-values) (generic function)

Direct Default Initargs
InitargValue
:schema-item(more-conditions:missing-required-initarg (quote configuration.options::option-cell) :schema-item)
Class: stream-source ()

This source reads and configuration data from streams.

Supplied streams are not closed after processing.

Package

configuration.options.sources

Source

source-stream.lisp (file)

Direct superclasses

print-items-mixin (class)

Direct subclasses

file-source (class)

Direct methods
Direct slots
Slot: stream

Stores the stream from which the source reads when processing.

Type

stream

Initargs

:stream

Readers
Writers

(setf source-%stream) (generic function)

Slot: syntax

Stores the syntax object which should be used to parse the contents of the processed stream.

Readers
Writers

(setf source-%syntax) (generic function)

Direct Default Initargs
InitargValue
:stream(more-conditions:missing-required-initarg (quote configuration.options.sources::stream-source) :stream)
:syntax(more-conditions:missing-required-initarg (quote configuration.options.sources::stream-source) :syntax)
Class: synchronizer-handler ()

Instances of this class are attached to event hooks of ‘option-cell’s by synchronizers in order to forward events to the event hooks of options.

Package

configuration.options

Source

synchronizer.lisp (file)

Direct superclasses

funcallable-standard-object (class)

Direct methods
Direct slots
Slot: synchronizer

Stores the synchronizer which created this handler.

Initargs

:synchronizer

Readers

synchronizer-handler-synchronizer (generic function)

Direct Default Initargs
InitargValue
:synchronizer(more-conditions:missing-required-initarg (quote configuration.options::synchronizer-handler) :synchronizer)
:option(more-conditions:missing-required-initarg (quote configuration.options::synchronizer-handler) :option)
Class: type-based-conversion-mixin ()

This mixin class is intended to be mixed into schema item classes which have to perform parsing and unparsing of values based their types.

This behavior is implemented by a methods on ‘value->string’ and ‘raw->value’ which call ‘value->string-using-type’ and ‘raw->value-using-type’ respectively with the ‘option-type’ of the schema item.

Default behavior is provided for some types:

* boolean
* integer
* string
* member
* pathname
* (list ELEMENT-TYPE [:inherit? INHERIT])
* (or ...)
* (and ...)

Package

configuration.options

Source

mixins.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

standard-schema-item (class)

Direct methods
Class: type-based-merging-mixin ()

This mixin class is intended to be mixed into schema item classes which have to perform merging of values based their types.

This behavior is implemented by a method on ‘merges-values’ which calls ‘merge-value-using-type’ with the ‘option-type’ of the schema item.

Default behavior is provided for some types:

* t: use the value with the highest priority; ignore other values

* (list [ELEMENT-TYPE [:inherit? INHERIT]]): depending on INHERIT either use the value with highest priority or look for :inherit markers in values and concatenate values appropriately.

Package

configuration.options

Source

mixins.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

standard-schema-item (class)

Direct methods
Class: type-based-validation-mixin ()

This mixin class is intended to be mixed into schema item classes which have to perform validation of values based their types.

This behavior is implemented by a method on ‘validate-value’ which calls ‘validate-value-using-type’ with the ‘option-type’ of the schema item.

Default behavior is provided for types of the forms

* (integer ...)
* (list [ELEMENT-TYPE [:inherit? INHERIT]])
* (and ...)
* (or ...)

Package

configuration.options

Source

mixins.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

standard-schema-item (class)

Direct methods

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

6.2.9 Types

Type: name ()

A sequence of name components some of which may be wild.

Package

configuration.options

Source

types.lisp (file)

Type: wild-name ()

A ‘name’ which has at least one wild component.

Package

configuration.options

Source

types.lisp (file)

Type: wildcard-interpretation ()
Package

configuration.options

Source

types.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   C   F   L   M  
Index Entry  Section

C
configuration.options.asd: The configuration<dot>options<dot>asd file
configuration.options/sources: The configuration<dot>options/sources module
configuration.options/sources/conditions.lisp: The configuration<dot>options/sources/conditions<dot>lisp file
configuration.options/sources/configuration-files.lisp: The configuration<dot>options/sources/configuration-files<dot>lisp file
configuration.options/sources/debug.lisp: The configuration<dot>options/sources/debug<dot>lisp file
configuration.options/sources/package.lisp: The configuration<dot>options/sources/package<dot>lisp file
configuration.options/sources/protocol.lisp: The configuration<dot>options/sources/protocol<dot>lisp file
configuration.options/sources/source-cascade.lisp: The configuration<dot>options/sources/source-cascade<dot>lisp file
configuration.options/sources/source-defaults.lisp: The configuration<dot>options/sources/source-defaults<dot>lisp file
configuration.options/sources/source-environment-variables.lisp: The configuration<dot>options/sources/source-environment-variables<dot>lisp file
configuration.options/sources/source-file.lisp: The configuration<dot>options/sources/source-file<dot>lisp file
configuration.options/sources/source-stream.lisp: The configuration<dot>options/sources/source-stream<dot>lisp file
configuration.options/src: The configuration<dot>options/src module
configuration.options/src/conditions.lisp: The configuration<dot>options/src/conditions<dot>lisp file
configuration.options/src/configuration.lisp: The configuration<dot>options/src/configuration<dot>lisp file
configuration.options/src/debug.lisp: The configuration<dot>options/src/debug<dot>lisp file
configuration.options/src/let-plus.lisp: The configuration<dot>options/src/let-plus<dot>lisp file
configuration.options/src/macros.lisp: The configuration<dot>options/src/macros<dot>lisp file
configuration.options/src/mixins.lisp: The configuration<dot>options/src/mixins<dot>lisp file
configuration.options/src/name.lisp: The configuration<dot>options/src/name<dot>lisp file
configuration.options/src/package.lisp: The configuration<dot>options/src/package<dot>lisp file
configuration.options/src/protocol.lisp: The configuration<dot>options/src/protocol<dot>lisp file
configuration.options/src/schema.lisp: The configuration<dot>options/src/schema<dot>lisp file
configuration.options/src/synchronizer.lisp: The configuration<dot>options/src/synchronizer<dot>lisp file
configuration.options/src/types.lisp: The configuration<dot>options/src/types<dot>lisp file
configuration.options/src/util.lisp: The configuration<dot>options/src/util<dot>lisp file
configuration.options/src/value-types.lisp: The configuration<dot>options/src/value-types<dot>lisp file
configuration.options/src/variables.lisp: The configuration<dot>options/src/variables<dot>lisp file

F
File, Lisp, configuration.options.asd: The configuration<dot>options<dot>asd file
File, Lisp, configuration.options/sources/conditions.lisp: The configuration<dot>options/sources/conditions<dot>lisp file
File, Lisp, configuration.options/sources/configuration-files.lisp: The configuration<dot>options/sources/configuration-files<dot>lisp file
File, Lisp, configuration.options/sources/debug.lisp: The configuration<dot>options/sources/debug<dot>lisp file
File, Lisp, configuration.options/sources/package.lisp: The configuration<dot>options/sources/package<dot>lisp file
File, Lisp, configuration.options/sources/protocol.lisp: The configuration<dot>options/sources/protocol<dot>lisp file
File, Lisp, configuration.options/sources/source-cascade.lisp: The configuration<dot>options/sources/source-cascade<dot>lisp file
File, Lisp, configuration.options/sources/source-defaults.lisp: The configuration<dot>options/sources/source-defaults<dot>lisp file
File, Lisp, configuration.options/sources/source-environment-variables.lisp: The configuration<dot>options/sources/source-environment-variables<dot>lisp file
File, Lisp, configuration.options/sources/source-file.lisp: The configuration<dot>options/sources/source-file<dot>lisp file
File, Lisp, configuration.options/sources/source-stream.lisp: The configuration<dot>options/sources/source-stream<dot>lisp file
File, Lisp, configuration.options/src/conditions.lisp: The configuration<dot>options/src/conditions<dot>lisp file
File, Lisp, configuration.options/src/configuration.lisp: The configuration<dot>options/src/configuration<dot>lisp file
File, Lisp, configuration.options/src/debug.lisp: The configuration<dot>options/src/debug<dot>lisp file
File, Lisp, configuration.options/src/let-plus.lisp: The configuration<dot>options/src/let-plus<dot>lisp file
File, Lisp, configuration.options/src/macros.lisp: The configuration<dot>options/src/macros<dot>lisp file
File, Lisp, configuration.options/src/mixins.lisp: The configuration<dot>options/src/mixins<dot>lisp file
File, Lisp, configuration.options/src/name.lisp: The configuration<dot>options/src/name<dot>lisp file
File, Lisp, configuration.options/src/package.lisp: The configuration<dot>options/src/package<dot>lisp file
File, Lisp, configuration.options/src/protocol.lisp: The configuration<dot>options/src/protocol<dot>lisp file
File, Lisp, configuration.options/src/schema.lisp: The configuration<dot>options/src/schema<dot>lisp file
File, Lisp, configuration.options/src/synchronizer.lisp: The configuration<dot>options/src/synchronizer<dot>lisp file
File, Lisp, configuration.options/src/types.lisp: The configuration<dot>options/src/types<dot>lisp file
File, Lisp, configuration.options/src/util.lisp: The configuration<dot>options/src/util<dot>lisp file
File, Lisp, configuration.options/src/value-types.lisp: The configuration<dot>options/src/value-types<dot>lisp file
File, Lisp, configuration.options/src/variables.lisp: The configuration<dot>options/src/variables<dot>lisp file

L
Lisp File, configuration.options.asd: The configuration<dot>options<dot>asd file
Lisp File, configuration.options/sources/conditions.lisp: The configuration<dot>options/sources/conditions<dot>lisp file
Lisp File, configuration.options/sources/configuration-files.lisp: The configuration<dot>options/sources/configuration-files<dot>lisp file
Lisp File, configuration.options/sources/debug.lisp: The configuration<dot>options/sources/debug<dot>lisp file
Lisp File, configuration.options/sources/package.lisp: The configuration<dot>options/sources/package<dot>lisp file
Lisp File, configuration.options/sources/protocol.lisp: The configuration<dot>options/sources/protocol<dot>lisp file
Lisp File, configuration.options/sources/source-cascade.lisp: The configuration<dot>options/sources/source-cascade<dot>lisp file
Lisp File, configuration.options/sources/source-defaults.lisp: The configuration<dot>options/sources/source-defaults<dot>lisp file
Lisp File, configuration.options/sources/source-environment-variables.lisp: The configuration<dot>options/sources/source-environment-variables<dot>lisp file
Lisp File, configuration.options/sources/source-file.lisp: The configuration<dot>options/sources/source-file<dot>lisp file
Lisp File, configuration.options/sources/source-stream.lisp: The configuration<dot>options/sources/source-stream<dot>lisp file
Lisp File, configuration.options/src/conditions.lisp: The configuration<dot>options/src/conditions<dot>lisp file
Lisp File, configuration.options/src/configuration.lisp: The configuration<dot>options/src/configuration<dot>lisp file
Lisp File, configuration.options/src/debug.lisp: The configuration<dot>options/src/debug<dot>lisp file
Lisp File, configuration.options/src/let-plus.lisp: The configuration<dot>options/src/let-plus<dot>lisp file
Lisp File, configuration.options/src/macros.lisp: The configuration<dot>options/src/macros<dot>lisp file
Lisp File, configuration.options/src/mixins.lisp: The configuration<dot>options/src/mixins<dot>lisp file
Lisp File, configuration.options/src/name.lisp: The configuration<dot>options/src/name<dot>lisp file
Lisp File, configuration.options/src/package.lisp: The configuration<dot>options/src/package<dot>lisp file
Lisp File, configuration.options/src/protocol.lisp: The configuration<dot>options/src/protocol<dot>lisp file
Lisp File, configuration.options/src/schema.lisp: The configuration<dot>options/src/schema<dot>lisp file
Lisp File, configuration.options/src/synchronizer.lisp: The configuration<dot>options/src/synchronizer<dot>lisp file
Lisp File, configuration.options/src/types.lisp: The configuration<dot>options/src/types<dot>lisp file
Lisp File, configuration.options/src/util.lisp: The configuration<dot>options/src/util<dot>lisp file
Lisp File, configuration.options/src/value-types.lisp: The configuration<dot>options/src/value-types<dot>lisp file
Lisp File, configuration.options/src/variables.lisp: The configuration<dot>options/src/variables<dot>lisp file

M
Module, configuration.options/sources: The configuration<dot>options/sources module
Module, configuration.options/src: The configuration<dot>options/src module

Jump to:   C   F   L   M  

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

A.2 Functions

Jump to:   %   &   (  
B   C   D   E   F   G   H   I   M   N   O   P   R   S   T   U   V   W  
Index Entry  Section

%
%children: Internal generic functions
%children: Internal generic functions
%every-element-name-component?: Internal functions
%has-wild-component?: Internal functions
%make-option-value: Internal functions
%maybe-check-detailed-type: Internal functions
%options: Internal generic functions
%options: Internal generic functions
%parse-value-binding: Internal functions
%update-value: Internal functions

&
&options: Exported macros
&options-r/o: Exported macros
&options/synchronizer: Exported macros

(
(setf %children): Internal generic functions
(setf %children): Internal generic functions
(setf %options): Internal generic functions
(setf %options): Internal generic functions
(setf find-child): Exported generic functions
(setf find-child): Exported generic functions
(setf find-child): Exported generic functions
(setf find-child): Exported generic functions
(setf find-child): Exported generic functions
(setf find-option): Exported generic functions
(setf find-option): Exported generic functions
(setf find-option): Exported generic functions
(setf find-option): Exported generic functions
(setf find-option): Exported generic functions
(setf find-option): Exported generic functions
(setf find-option): Exported generic functions
(setf option-%default): Internal generic functions
(setf option-%default): Internal generic functions
(setf option-%default): Internal generic functions
(setf option-%default): Internal generic functions
(setf option-%name): Internal generic functions
(setf option-%name): Internal generic functions
(setf option-%value): Internal generic functions
(setf option-%value): Internal generic functions
(setf option-documentation): Exported generic functions
(setf option-documentation): Exported generic functions
(setf option-value): Exported generic functions
(setf option-value): Exported generic functions
(setf option-value): Exported generic functions
(setf option-value): Exported generic functions
(setf option-value): Exported generic functions
(setf option-values): Exported generic functions
(setf option-values): Exported generic functions
(setf option-values): Exported generic functions
(setf source-%name-mapping): Internal generic functions
(setf source-%name-mapping): Internal generic functions
(setf source-%pathname): Internal generic functions
(setf source-%pathname): Internal generic functions
(setf source-%schema): Internal generic functions
(setf source-%schema): Internal generic functions
(setf source-%sources): Internal generic functions
(setf source-%sources): Internal generic functions
(setf source-%stream): Internal generic functions
(setf source-%stream): Internal generic functions
(setf source-%syntax): Internal generic functions
(setf source-%syntax): Internal generic functions
(setf value): Exported generic functions
(setf value): Exported generic functions
(setf value): Exported generic functions

B
binding-condition-container: Exported generic functions
binding-condition-container: Exported generic functions
binding-condition-name: Exported generic functions
binding-condition-name: Exported generic functions
binding-exists-condition-existing: Exported generic functions
binding-exists-condition-existing: Exported generic functions

C
call-with-indent: Exported functions
call-with-level: Exported functions
call-with-source-debug: Internal functions
config-debug-variable-name: Exported functions
config-files-variable-name: Internal functions
config-files-variable-value: Internal functions
configuration-file-specs: Exported functions
configuration-files: Exported functions
configuration-schema: Exported generic functions
configuration-schema: Exported generic functions
copy-indexed-sink: Internal functions

D
define-dispatch-methods: Internal macros
define-schema: Exported macros

E
enable-debugging: Exported functions
environment-variable-namify: Internal functions
eval-schema-spec: Exported functions
event-hook: Exported generic functions
event-hook: Exported generic functions

F
find-child: Exported generic functions
find-child: Exported generic functions
find-child: Exported generic functions
find-child: Exported generic functions
find-option: Exported generic functions
find-option: Exported generic functions
find-option: Exported generic functions
find-option: Exported generic functions
find-option: Exported generic functions
find-option: Exported generic functions
find-options: Exported generic functions
find-options: Exported generic functions
find-options: Exported generic functions
Function, %every-element-name-component?: Internal functions
Function, %has-wild-component?: Internal functions
Function, %make-option-value: Internal functions
Function, %maybe-check-detailed-type: Internal functions
Function, %parse-value-binding: Internal functions
Function, %update-value: Internal functions
Function, call-with-indent: Exported functions
Function, call-with-level: Exported functions
Function, call-with-source-debug: Internal functions
Function, config-debug-variable-name: Exported functions
Function, config-files-variable-name: Internal functions
Function, config-files-variable-value: Internal functions
Function, configuration-file-specs: Exported functions
Function, configuration-files: Exported functions
Function, copy-indexed-sink: Internal functions
Function, enable-debugging: Exported functions
Function, environment-variable-namify: Internal functions
Function, eval-schema-spec: Exported functions
Function, handler-of: Internal functions
Function, ignore-meta-configuration-variables: Internal functions
Function, indexed-sink-index: Internal functions
Function, indexed-sink-p: Internal functions
Function, indexed-sink-sink: Internal functions
Function, make-environment-variable-name->option-name: Internal functions
Function, make-indexed-sink: Internal functions
Function, map-query-alignments: Internal functions
Function, map-schema-spec: Exported functions
Function, maybe-enable-debugging: Exported functions
Function, output: Exported functions
Function, parse-name: Exported functions
Function, print-documentation: Internal functions
Function, print-name: Exported functions
Function, print-option-container-tree: Exported functions
Function, system-configuration-directory: Internal functions
Function, typexpand-1: Internal functions
Function, typexpand-1-unless-builtin: Internal functions
Function, user-configuration-directory: Internal functions

G
Generic Function, %children: Internal generic functions
Generic Function, %options: Internal generic functions
Generic Function, (setf %children): Internal generic functions
Generic Function, (setf %options): Internal generic functions
Generic Function, (setf find-child): Exported generic functions
Generic Function, (setf find-option): Exported generic functions
Generic Function, (setf option-%default): Internal generic functions
Generic Function, (setf option-%name): Internal generic functions
Generic Function, (setf option-%value): Internal generic functions
Generic Function, (setf option-documentation): Exported generic functions
Generic Function, (setf option-value): Exported generic functions
Generic Function, (setf option-values): Exported generic functions
Generic Function, (setf source-%name-mapping): Internal generic functions
Generic Function, (setf source-%pathname): Internal generic functions
Generic Function, (setf source-%schema): Internal generic functions
Generic Function, (setf source-%sources): Internal generic functions
Generic Function, (setf source-%stream): Internal generic functions
Generic Function, (setf source-%syntax): Internal generic functions
Generic Function, (setf value): Exported generic functions
Generic Function, binding-condition-container: Exported generic functions
Generic Function, binding-condition-name: Exported generic functions
Generic Function, binding-exists-condition-existing: Exported generic functions
Generic Function, configuration-schema: Exported generic functions
Generic Function, event-hook: Exported generic functions
Generic Function, find-child: Exported generic functions
Generic Function, find-option: Exported generic functions
Generic Function, find-options: Exported generic functions
Generic Function, initialize: Exported generic functions
Generic Function, make-configuration: Exported generic functions
Generic Function, make-name: Exported generic functions
Generic Function, make-option: Exported generic functions
Generic Function, make-source: Exported generic functions
Generic Function, make-syntax: Exported generic functions
Generic Function, map-matching-options: Exported generic functions
Generic Function, map-options: Exported generic functions
Generic Function, merge-names: Exported generic functions
Generic Function, merge-values: Exported generic functions
Generic Function, merge-values-using-type: Exported generic functions
Generic Function, name-components: Exported generic functions
Generic Function, name-equal: Exported generic functions
Generic Function, name-matches: Exported generic functions
Generic Function, name-parse-error-text: Exported generic functions
Generic Function, name<: Exported generic functions
Generic Function, notification-error-event: Exported generic functions
Generic Function, notification-error-name: Exported generic functions
Generic Function, notification-error-sink: Exported generic functions
Generic Function, notification-error-source: Exported generic functions
Generic Function, notify: Exported generic functions
Generic Function, option-%cell: Internal generic functions
Generic Function, option-%default: Internal generic functions
Generic Function, option-%value: Internal generic functions
Generic Function, option-class: Exported generic functions
Generic Function, option-condition-option: Exported generic functions
Generic Function, option-configuration: Exported generic functions
Generic Function, option-default: Exported generic functions
Generic Function, option-documentation: Exported generic functions
Generic Function, option-name: Exported generic functions
Generic Function, option-schema-item: Exported generic functions
Generic Function, option-syntax-error-type: Exported generic functions
Generic Function, option-type: Exported generic functions
Generic Function, option-value: Exported generic functions
Generic Function, option-values: Exported generic functions
Generic Function, options: Exported generic functions
Generic Function, process: Exported generic functions
Generic Function, process-content: Exported generic functions
Generic Function, raw->value: Exported generic functions
Generic Function, raw->value-using-type: Exported generic functions
Generic Function, schema-children: Exported generic functions
Generic Function, schema-children/alist: Internal generic functions
Generic Function, schema-condition-schema: Exported generic functions
Generic Function, schema-syntax-error-specification: Exported generic functions
Generic Function, sink-condition-sink: Exported generic functions
Generic Function, source-%name-mapping: Internal generic functions
Generic Function, source-%pathname: Internal generic functions
Generic Function, source-%schema: Internal generic functions
Generic Function, source-%sources: Internal generic functions
Generic Function, source-%stream: Internal generic functions
Generic Function, source-%syntax: Internal generic functions
Generic Function, source-condition-source: Exported generic functions
Generic Function, source-description: Internal generic functions
Generic Function, source-element-type: Internal generic functions
Generic Function, source-if-does-not-exist: Internal generic functions
Generic Function, source-name-mapping: Internal generic functions
Generic Function, source-pathname: Internal generic functions
Generic Function, source-pattern: Internal generic functions
Generic Function, source-sources: Exported generic functions
Generic Function, source-stream: Internal generic functions
Generic Function, source-syntax: Internal generic functions
Generic Function, sub-configuration: Exported generic functions
Generic Function, synchronizer-handler-synchronizer: Internal generic functions
Generic Function, synchronizer-target: Exported generic functions
Generic Function, validate-value: Exported generic functions
Generic Function, validate-value-using-type: Exported generic functions
Generic Function, value: Exported generic functions
Generic Function, value->string: Exported generic functions
Generic Function, value->string-using-type: Exported generic functions
Generic Function, value-condition-value: Exported generic functions
Generic Function, value-missing-condition-which: Exported generic functions

H
handler-of: Internal functions

I
if-name: Internal macros
ignore-meta-configuration-variables: Internal functions
indexed-sink-index: Internal functions
indexed-sink-p: Internal functions
indexed-sink-sink: Internal functions
initialize: Exported generic functions
initialize: Exported generic functions
initialize: Exported generic functions
initialize: Exported generic functions
initialize: Exported generic functions

M
Macro, &options: Exported macros
Macro, &options-r/o: Exported macros
Macro, &options/synchronizer: Exported macros
Macro, define-dispatch-methods: Internal macros
Macro, define-schema: Exported macros
Macro, if-name: Internal macros
Macro, with-indent: Exported macros
Macro, with-level: Exported macros
Macro, with-source-debug: Internal macros
make-configuration: Exported generic functions
make-configuration: Exported generic functions
make-environment-variable-name->option-name: Internal functions
make-indexed-sink: Internal functions
make-name: Exported generic functions
make-name: Exported generic functions
make-name: Exported generic functions
make-name: Exported generic functions
make-name: Exported generic functions
make-option: Exported generic functions
make-option: Exported generic functions
make-option: Exported generic functions
make-source: Exported generic functions
make-source: Exported generic functions
make-syntax: Exported generic functions
make-syntax: Exported generic functions
map-matching-options: Exported generic functions
map-matching-options: Exported generic functions
map-matching-options: Exported generic functions
map-matching-options: Exported generic functions
map-options: Exported generic functions
map-options: Exported generic functions
map-options: Exported generic functions
map-options: Exported generic functions
map-query-alignments: Internal functions
map-schema-spec: Exported functions
maybe-enable-debugging: Exported functions
merge-names: Exported generic functions
merge-names: Exported generic functions
merge-names: Exported generic functions
merge-names: Exported generic functions
merge-values: Exported generic functions
merge-values: Exported generic functions
merge-values-using-type: Exported generic functions
merge-values-using-type: Exported generic functions
merge-values-using-type: Exported generic functions
merge-values-using-type: Exported generic functions
merge-values-using-type: Exported generic functions
Method, %children: Internal generic functions
Method, %options: Internal generic functions
Method, (setf %children): Internal generic functions
Method, (setf %options): Internal generic functions
Method, (setf find-child): Exported generic functions
Method, (setf find-child): Exported generic functions
Method, (setf find-child): Exported generic functions
Method, (setf find-child): Exported generic functions
Method, (setf find-option): Exported generic functions
Method, (setf find-option): Exported generic functions
Method, (setf find-option): Exported generic functions
Method, (setf find-option): Exported generic functions
Method, (setf find-option): Exported generic functions
Method, (setf find-option): Exported generic functions
Method, (setf option-%default): Internal generic functions
Method, (setf option-%default): Internal generic functions
Method, (setf option-%default): Internal generic functions
Method, (setf option-%name): Internal generic functions
Method, (setf option-%value): Internal generic functions
Method, (setf option-documentation): Exported generic functions
Method, (setf option-value): Exported generic functions
Method, (setf option-value): Exported generic functions
Method, (setf option-value): Exported generic functions
Method, (setf option-value): Exported generic functions
Method, (setf option-values): Exported generic functions
Method, (setf option-values): Exported generic functions
Method, (setf source-%name-mapping): Internal generic functions
Method, (setf source-%pathname): Internal generic functions
Method, (setf source-%schema): Internal generic functions
Method, (setf source-%sources): Internal generic functions
Method, (setf source-%stream): Internal generic functions
Method, (setf source-%syntax): Internal generic functions
Method, (setf value): Exported generic functions
Method, (setf value): Exported generic functions
Method, binding-condition-container: Exported generic functions
Method, binding-condition-name: Exported generic functions
Method, binding-exists-condition-existing: Exported generic functions
Method, configuration-schema: Exported generic functions
Method, event-hook: Exported generic functions
Method, find-child: Exported generic functions
Method, find-child: Exported generic functions
Method, find-child: Exported generic functions
Method, find-option: Exported generic functions
Method, find-option: Exported generic functions
Method, find-option: Exported generic functions
Method, find-option: Exported generic functions
Method, find-option: Exported generic functions
Method, find-options: Exported generic functions
Method, find-options: Exported generic functions
Method, initialize: Exported generic functions
Method, initialize: Exported generic functions
Method, initialize: Exported generic functions
Method, initialize: Exported generic functions
Method, make-configuration: Exported generic functions
Method, make-name: Exported generic functions
Method, make-name: Exported generic functions
Method, make-name: Exported generic functions
Method, make-name: Exported generic functions
Method, make-option: Exported generic functions
Method, make-option: Exported generic functions
Method, make-source: Exported generic functions
Method, make-syntax: Exported generic functions
Method, map-matching-options: Exported generic functions
Method, map-matching-options: Exported generic functions
Method, map-matching-options: Exported generic functions
Method, map-options: Exported generic functions
Method, map-options: Exported generic functions
Method, map-options: Exported generic functions
Method, merge-names: Exported generic functions
Method, merge-names: Exported generic functions
Method, merge-names: Exported generic functions
Method, merge-values: Exported generic functions
Method, merge-values-using-type: Exported generic functions
Method, merge-values-using-type: Exported generic functions
Method, merge-values-using-type: Exported generic functions
Method, merge-values-using-type: Exported generic functions
Method, name-components: Exported generic functions
Method, name-components: Exported generic functions
Method, name-equal: Exported generic functions
Method, name-matches: Exported generic functions
Method, name-matches: Exported generic functions
Method, name-matches: Exported generic functions
Method, name-parse-error-text: Exported generic functions
Method, name<: Exported generic functions
Method, name<: Exported generic functions
Method, name<: Exported generic functions
Method, notification-error-event: Exported generic functions
Method, notification-error-name: Exported generic functions
Method, notification-error-sink: Exported generic functions
Method, notification-error-source: Exported generic functions
Method, notify: Exported generic functions
Method, notify: Exported generic functions
Method, notify: Exported generic functions
Method, notify: Exported generic functions
Method, notify: Exported generic functions
Method, option-%cell: Internal generic functions
Method, option-%default: Internal generic functions
Method, option-%value: Internal generic functions
Method, option-class: Exported generic functions
Method, option-condition-option: Exported generic functions
Method, option-default: Exported generic functions
Method, option-default: Exported generic functions
Method, option-default: Exported generic functions
Method, option-default: Exported generic functions
Method, option-documentation: Exported generic functions
Method, option-documentation: Exported generic functions
Method, option-documentation: Exported generic functions
Method, option-documentation: Exported generic functions
Method, option-name: Exported generic functions
Method, option-schema-item: Exported generic functions
Method, option-schema-item: Exported generic functions
Method, option-syntax-error-type: Exported generic functions
Method, option-type: Exported generic functions
Method, option-type: Exported generic functions
Method, option-type: Exported generic functions
Method, option-value: Exported generic functions
Method, option-value: Exported generic functions
Method, option-value: Exported generic functions
Method, option-values: Exported generic functions
Method, option-values: Exported generic functions
Method, options: Exported generic functions
Method, process: Exported generic functions
Method, process: Exported generic functions
Method, process: Exported generic functions
Method, process: Exported generic functions
Method, process: Exported generic functions
Method, process: Exported generic functions
Method, raw->value: Exported generic functions
Method, raw->value: Exported generic functions
Method, raw->value-using-type: Exported generic functions
Method, raw->value-using-type: Exported generic functions
Method, raw->value-using-type: Exported generic functions
Method, raw->value-using-type: Exported generic functions
Method, raw->value-using-type: Exported generic functions
Method, raw->value-using-type: Exported generic functions
Method, raw->value-using-type: Exported generic functions
Method, raw->value-using-type: Exported generic functions
Method, raw->value-using-type: Exported generic functions
Method, raw->value-using-type: Exported generic functions
Method, raw->value-using-type: Exported generic functions
Method, raw->value-using-type: Exported generic functions
Method, raw->value-using-type: Exported generic functions
Method, schema-children: Exported generic functions
Method, schema-children/alist: Internal generic functions
Method, schema-condition-schema: Exported generic functions
Method, schema-syntax-error-specification: Exported generic functions
Method, sink-condition-sink: Exported generic functions
Method, source-%name-mapping: Internal generic functions
Method, source-%pathname: Internal generic functions
Method, source-%schema: Internal generic functions
Method, source-%sources: Internal generic functions
Method, source-%stream: Internal generic functions
Method, source-%syntax: Internal generic functions
Method, source-condition-source: Exported generic functions
Method, source-description: Internal generic functions
Method, source-element-type: Internal generic functions
Method, source-if-does-not-exist: Internal generic functions
Method, source-name-mapping: Internal generic functions
Method, source-pathname: Internal generic functions
Method, source-pattern: Internal generic functions
Method, source-sources: Exported generic functions
Method, source-sources: Exported generic functions
Method, source-stream: Internal generic functions
Method, source-syntax: Internal generic functions
Method, sub-configuration: Exported generic functions
Method, sub-configuration: Exported generic functions
Method, synchronizer-handler-synchronizer: Internal generic functions
Method, synchronizer-target: Exported generic functions
Method, validate-value: Exported generic functions
Method, validate-value: Exported generic functions
Method, validate-value-using-type: Exported generic functions
Method, validate-value-using-type: Exported generic functions
Method, validate-value-using-type: Exported generic functions
Method, validate-value-using-type: Exported generic functions
Method, validate-value-using-type: Exported generic functions
Method, validate-value-using-type: Exported generic functions
Method, value: Exported generic functions
Method, value: Exported generic functions
Method, value->string: Exported generic functions
Method, value->string-using-type: Exported generic functions
Method, value->string-using-type: Exported generic functions
Method, value->string-using-type: Exported generic functions
Method, value->string-using-type: Exported generic functions
Method, value->string-using-type: Exported generic functions
Method, value->string-using-type: Exported generic functions
Method, value->string-using-type: Exported generic functions
Method, value->string-using-type: Exported generic functions
Method, value->string-using-type: Exported generic functions
Method, value->string-using-type: Exported generic functions
Method, value->string-using-type: Exported generic functions
Method, value-condition-value: Exported generic functions
Method, value-missing-condition-which: Exported generic functions

N
name-components: Exported generic functions
name-components: Exported generic functions
name-components: Exported generic functions
name-equal: Exported generic functions
name-equal: Exported generic functions
name-matches: Exported generic functions
name-matches: Exported generic functions
name-matches: Exported generic functions
name-matches: Exported generic functions
name-parse-error-text: Exported generic functions
name-parse-error-text: Exported generic functions
name<: Exported generic functions
name<: Exported generic functions
name<: Exported generic functions
name<: Exported generic functions
notification-error-event: Exported generic functions
notification-error-event: Exported generic functions
notification-error-name: Exported generic functions
notification-error-name: Exported generic functions
notification-error-sink: Exported generic functions
notification-error-sink: Exported generic functions
notification-error-source: Exported generic functions
notification-error-source: Exported generic functions
notify: Exported generic functions
notify: Exported generic functions
notify: Exported generic functions
notify: Exported generic functions
notify: Exported generic functions
notify: Exported generic functions

O
option-%cell: Internal generic functions
option-%cell: Internal generic functions
option-%default: Internal generic functions
option-%default: Internal generic functions
option-%value: Internal generic functions
option-%value: Internal generic functions
option-class: Exported generic functions
option-class: Exported generic functions
option-condition-option: Exported generic functions
option-condition-option: Exported generic functions
option-configuration: Exported generic functions
option-default: Exported generic functions
option-default: Exported generic functions
option-default: Exported generic functions
option-default: Exported generic functions
option-default: Exported generic functions
option-documentation: Exported generic functions
option-documentation: Exported generic functions
option-documentation: Exported generic functions
option-documentation: Exported generic functions
option-documentation: Exported generic functions
option-name: Exported generic functions
option-name: Exported generic functions
option-schema-item: Exported generic functions
option-schema-item: Exported generic functions
option-schema-item: Exported generic functions
option-syntax-error-type: Exported generic functions
option-syntax-error-type: Exported generic functions
option-type: Exported generic functions
option-type: Exported generic functions
option-type: Exported generic functions
option-type: Exported generic functions
option-value: Exported generic functions
option-value: Exported generic functions
option-value: Exported generic functions
option-value: Exported generic functions
option-values: Exported generic functions
option-values: Exported generic functions
option-values: Exported generic functions
options: Exported generic functions
options: Exported generic functions
output: Exported functions

P
parse-name: Exported functions
print-documentation: Internal functions
print-name: Exported functions
print-option-container-tree: Exported functions
process: Exported generic functions
process: Exported generic functions
process: Exported generic functions
process: Exported generic functions
process: Exported generic functions
process: Exported generic functions
process: Exported generic functions
process-content: Exported generic functions

R
raw->value: Exported generic functions
raw->value: Exported generic functions
raw->value: Exported generic functions
raw->value-using-type: Exported generic functions
raw->value-using-type: Exported generic functions
raw->value-using-type: Exported generic functions
raw->value-using-type: Exported generic functions
raw->value-using-type: Exported generic functions
raw->value-using-type: Exported generic functions
raw->value-using-type: Exported generic functions
raw->value-using-type: Exported generic functions
raw->value-using-type: Exported generic functions
raw->value-using-type: Exported generic functions
raw->value-using-type: Exported generic functions
raw->value-using-type: Exported generic functions
raw->value-using-type: Exported generic functions
raw->value-using-type: Exported generic functions

S
schema-children: Exported generic functions
schema-children: Exported generic functions
schema-children/alist: Internal generic functions
schema-children/alist: Internal generic functions
schema-condition-schema: Exported generic functions
schema-condition-schema: Exported generic functions
schema-syntax-error-specification: Exported generic functions
schema-syntax-error-specification: Exported generic functions
sink-condition-sink: Exported generic functions
sink-condition-sink: Exported generic functions
source-%name-mapping: Internal generic functions
source-%name-mapping: Internal generic functions
source-%pathname: Internal generic functions
source-%pathname: Internal generic functions
source-%schema: Internal generic functions
source-%schema: Internal generic functions
source-%sources: Internal generic functions
source-%sources: Internal generic functions
source-%stream: Internal generic functions
source-%stream: Internal generic functions
source-%syntax: Internal generic functions
source-%syntax: Internal generic functions
source-condition-source: Exported generic functions
source-condition-source: Exported generic functions
source-description: Internal generic functions
source-description: Internal generic functions
source-element-type: Internal generic functions
source-element-type: Internal generic functions
source-if-does-not-exist: Internal generic functions
source-if-does-not-exist: Internal generic functions
source-name-mapping: Internal generic functions
source-name-mapping: Internal generic functions
source-pathname: Internal generic functions
source-pathname: Internal generic functions
source-pattern: Internal generic functions
source-pattern: Internal generic functions
source-sources: Exported generic functions
source-sources: Exported generic functions
source-sources: Exported generic functions
source-stream: Internal generic functions
source-stream: Internal generic functions
source-syntax: Internal generic functions
source-syntax: Internal generic functions
sub-configuration: Exported generic functions
sub-configuration: Exported generic functions
sub-configuration: Exported generic functions
synchronizer-handler-synchronizer: Internal generic functions
synchronizer-handler-synchronizer: Internal generic functions
synchronizer-target: Exported generic functions
synchronizer-target: Exported generic functions
system-configuration-directory: Internal functions

T
typexpand-1: Internal functions
typexpand-1-unless-builtin: Internal functions

U
user-configuration-directory: Internal functions

V
validate-value: Exported generic functions
validate-value: Exported generic functions
validate-value: Exported generic functions
validate-value-using-type: Exported generic functions
validate-value-using-type: Exported generic functions
validate-value-using-type: Exported generic functions
validate-value-using-type: Exported generic functions
validate-value-using-type: Exported generic functions
validate-value-using-type: Exported generic functions
validate-value-using-type: Exported generic functions
value: Exported generic functions
value: Exported generic functions
value: Exported generic functions
value->string: Exported generic functions
value->string: Exported generic functions
value->string-using-type: Exported generic functions
value->string-using-type: Exported generic functions
value->string-using-type: Exported generic functions
value->string-using-type: Exported generic functions
value->string-using-type: Exported generic functions
value->string-using-type: Exported generic functions
value->string-using-type: Exported generic functions
value->string-using-type: Exported generic functions
value->string-using-type: Exported generic functions
value->string-using-type: Exported generic functions
value->string-using-type: Exported generic functions
value->string-using-type: Exported generic functions
value-condition-value: Exported generic functions
value-condition-value: Exported generic functions
value-missing-condition-which: Exported generic functions
value-missing-condition-which: Exported generic functions

W
with-indent: Exported macros
with-level: Exported macros
with-source-debug: Internal macros

Jump to:   %   &   (  
B   C   D   E   F   G   H   I   M   N   O   P   R   S   T   U   V   W  

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

A.3 Variables

Jump to:   *   +  
C   D   E   I   N   O   P   S   T   V   W  
Index Entry  Section

*
*configuration*: Exported special variables
*debug-index*: Internal special variables
*default-configuration-files*: Internal special variables
*level*: Internal special variables
*parse-wild-allowed*: Internal special variables
*parse-wild-inferiors-allowed*: Internal special variables
*stream*: Internal special variables

+
+config-debug-variable-suffix+: Exported constants
+config-file-pwd-placeholder+: Internal constants
+config-file-system-placeholder+: Internal constants
+config-file-user-placeholder+: Internal constants
+config-files-variable-suffix+: Internal constants
+no-value+: Internal constants

C
cell: Exported classes
children: Exported classes
components: Exported classes
Constant, +config-debug-variable-suffix+: Exported constants
Constant, +config-file-pwd-placeholder+: Internal constants
Constant, +config-file-system-placeholder+: Internal constants
Constant, +config-file-user-placeholder+: Internal constants
Constant, +config-files-variable-suffix+: Internal constants
Constant, +no-value+: Internal constants
container: Exported conditions

D
default: Exported classes
description: Internal classes
documentation: Internal classes

E
element-type: Internal classes
event: Exported conditions
event-hook: Internal classes
existing: Exported conditions

I
if-does-not-exist: Internal classes
index: Internal structures

N
name: Exported conditions
name: Exported conditions
name: Internal classes
name-mapping: Internal classes

O
option: Internal conditions
option-class: Exported classes
options: Internal classes

P
pathname: Internal classes
pattern: Internal classes

S
schema: Exported conditions
schema: Exported classes
schema: Internal classes
schema-item: Internal classes
sink: Exported conditions
sink: Exported conditions
sink: Internal structures
Slot, cell: Exported classes
Slot, children: Exported classes
Slot, components: Exported classes
Slot, container: Exported conditions
Slot, default: Exported classes
Slot, description: Internal classes
Slot, documentation: Internal classes
Slot, element-type: Internal classes
Slot, event: Exported conditions
Slot, event-hook: Internal classes
Slot, existing: Exported conditions
Slot, if-does-not-exist: Internal classes
Slot, index: Internal structures
Slot, name: Exported conditions
Slot, name: Exported conditions
Slot, name: Internal classes
Slot, name-mapping: Internal classes
Slot, option: Internal conditions
Slot, option-class: Exported classes
Slot, options: Internal classes
Slot, pathname: Internal classes
Slot, pattern: Internal classes
Slot, schema: Exported conditions
Slot, schema: Exported classes
Slot, schema: Internal classes
Slot, schema-item: Internal classes
Slot, sink: Exported conditions
Slot, sink: Exported conditions
Slot, sink: Internal structures
Slot, source: Exported conditions
Slot, source: Exported conditions
Slot, sources: Internal classes
Slot, specification: Exported conditions
Slot, stream: Internal classes
Slot, synchronizer: Internal classes
Slot, syntax: Internal classes
Slot, target: Exported classes
Slot, text: Exported conditions
Slot, type: Exported conditions
Slot, type: Exported classes
Slot, value: Internal conditions
Slot, value: Internal classes
Slot, values: Internal classes
Slot, which: Exported conditions
source: Exported conditions
source: Exported conditions
sources: Internal classes
Special Variable, *configuration*: Exported special variables
Special Variable, *debug-index*: Internal special variables
Special Variable, *default-configuration-files*: Internal special variables
Special Variable, *level*: Internal special variables
Special Variable, *parse-wild-allowed*: Internal special variables
Special Variable, *parse-wild-inferiors-allowed*: Internal special variables
Special Variable, *stream*: Internal special variables
specification: Exported conditions
stream: Internal classes
synchronizer: Internal classes
syntax: Internal classes

T
target: Exported classes
text: Exported conditions
type: Exported conditions
type: Exported classes

V
value: Internal conditions
value: Internal classes
values: Internal classes

W
which: Exported conditions

Jump to:   *   +  
C   D   E   I   N   O   P   S   T   V   W  

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

A.4 Data types

Jump to:   B   C   D   E   F   I   L   N   O   P   S   T   V   W  
Index Entry  Section

B
binding-condition: Exported conditions
binding-exists-condition: Exported conditions
binding-missing-condition: Exported conditions

C
cascade-source: Internal classes
child-exists-error: Exported conditions
child-exists-warning: Exported conditions
child-missing-error: Exported conditions
child-missing-warning: Exported conditions
Class, cascade-source: Internal classes
Class, common-cascade-source: Internal classes
Class, config-file-cascade-source: Internal classes
Class, defaults-source: Internal classes
Class, describe-via-map-options-mixin: Internal classes
Class, directory-source: Internal classes
Class, documentation-mixin: Internal classes
Class, environment-variables-source: Internal classes
Class, event-hook-mixin: Internal classes
Class, file-source: Internal classes
Class, list-container-mixin: Internal classes
Class, named-mixin: Internal classes
Class, option-cell: Internal classes
Class, standard-configuration: Exported classes
Class, standard-option: Exported classes
Class, standard-schema: Exported classes
Class, standard-schema-item: Exported classes
Class, standard-synchronizer: Exported classes
Class, stream-source: Internal classes
Class, synchronizer-handler: Internal classes
Class, type-based-conversion-mixin: Internal classes
Class, type-based-merging-mixin: Internal classes
Class, type-based-validation-mixin: Internal classes
Class, wildcard-name: Exported classes
common-cascade-source: Internal classes
Condition, binding-condition: Exported conditions
Condition, binding-exists-condition: Exported conditions
Condition, binding-missing-condition: Exported conditions
Condition, child-exists-error: Exported conditions
Condition, child-exists-warning: Exported conditions
Condition, child-missing-error: Exported conditions
Condition, child-missing-warning: Exported conditions
Condition, initialization-error: Exported conditions
Condition, name-parse-error: Exported conditions
Condition, notification-error: Exported conditions
Condition, option-condition: Internal conditions
Condition, option-exists-error: Exported conditions
Condition, option-exists-warning: Exported conditions
Condition, option-missing-error: Exported conditions
Condition, option-missing-warning: Exported conditions
Condition, option-syntax-error: Exported conditions
Condition, option-value-error: Exported conditions
Condition, processing-error: Exported conditions
Condition, schema-condition: Exported conditions
Condition, schema-syntax-error: Exported conditions
Condition, sink-condition: Exported conditions
Condition, source-condition: Exported conditions
Condition, value-condition: Internal conditions
Condition, value-missing-condition: Exported conditions
Condition, value-missing-error: Exported conditions
Condition, value-missing-warning: Exported conditions
config-file-cascade-source: Internal classes
configuration.options: The configuration<dot>options system
configuration.options: The configuration<dot>options package
configuration.options.debug: The configuration<dot>options<dot>debug package
configuration.options.sources: The configuration<dot>options<dot>sources package

D
defaults-source: Internal classes
describe-via-map-options-mixin: Internal classes
directory-source: Internal classes
documentation-mixin: Internal classes

E
environment-variables-source: Internal classes
event-hook-mixin: Internal classes

F
file-source: Internal classes

I
indexed-sink: Internal structures
initialization-error: Exported conditions

L
list-container-mixin: Internal classes

N
name: Internal types
name-component: Exported types
name-parse-error: Exported conditions
named-mixin: Internal classes
non-wild-name-component: Exported types
notification-error: Exported conditions

O
option-cell: Internal classes
option-condition: Internal conditions
option-exists-error: Exported conditions
option-exists-warning: Exported conditions
option-missing-error: Exported conditions
option-missing-warning: Exported conditions
option-syntax-error: Exported conditions
option-value-error: Exported conditions

P
Package, configuration.options: The configuration<dot>options package
Package, configuration.options.debug: The configuration<dot>options<dot>debug package
Package, configuration.options.sources: The configuration<dot>options<dot>sources package
processing-error: Exported conditions

S
schema-condition: Exported conditions
schema-syntax-error: Exported conditions
sink-condition: Exported conditions
source-condition: Exported conditions
standard-configuration: Exported classes
standard-option: Exported classes
standard-schema: Exported classes
standard-schema-item: Exported classes
standard-synchronizer: Exported classes
stream-source: Internal classes
Structure, indexed-sink: Internal structures
synchronizer-handler: Internal classes
System, configuration.options: The configuration<dot>options system

T
Type, name: Internal types
Type, name-component: Exported types
Type, non-wild-name-component: Exported types
Type, wild-name: Internal types
Type, wild-name-component: Exported types
Type, wildcard-interpretation: Internal types
type-based-conversion-mixin: Internal classes
type-based-merging-mixin: Internal classes
type-based-validation-mixin: Internal classes

V
value-condition: Internal conditions
value-missing-condition: Exported conditions
value-missing-error: Exported conditions
value-missing-warning: Exported conditions

W
wild-name: Internal types
wild-name-component: Exported types
wildcard-interpretation: Internal types
wildcard-name: Exported classes

Jump to:   B   C   D   E   F   I   L   N   O   P   S   T   V   W