The data-format-validation Reference Manual

Table of Contents

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

The data-format-validation Reference Manual

This is the data-format-validation Reference Manual, version 0.2.0, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 11:03:09 2018 GMT+0.


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

1 Introduction

.. -*-RST-*-
.. |VERSION| replace:: 0.1.6

========================
DATA FORMAT VALIDATION
========================

:Author:       Dr John A.R. Williams
:Contact:      J.A.R.Williams@jarw.org.uk
:date:         2010/04/08
:status:       Initial Public Release
:version:      |VERSION|
:copyright:    © 2011 J.A.R. Williams
:abstract:     DATA-FORMAT-VALIDATION is a library for Common Lisp providing a
     consistent regular interface for converting (and validating) external data
     (in the form of strings usually) into internal data types and
     for formatting internal data back into external presentable
     strings, all according to a conversion or type specification. 

.. meta::
   :keywords: Common Lisp

.. contents:: Table of Contents

.. |DFV| replace:: DATA-FORMAT-VALIDATION
.. |JARW| replace:: John A.R. Williams

Download and Installation
=========================

|DFV| together with this documentation can be downloaded from the git
repository at
`` or from
. The
current release version is |VERSION|.

|DFV| comes with a system definition for 
`ASDF `_ and is compiled and loaded in the usual
way. It depends upon `CL-PPCRE `_.

|DFV|  is made available under the terms of the GPL v3 license - see
the file ``LICENSE.txt`` for details.

Support
=======

For questions, bug reports, feature requests, improvements, or patches
please email .

The API
=======

generic function **parse-input** `specification value &key &allow-other-keys => object`
   Validate and parse user input according to
   specification, returning the validated object. Throws an invalid-input
   condition if input is invalid.  If specification is a list the first
   element specifies the actual validation method and the rest of the
   list are passed as keyword arguments to the specific method::

     (parse-input '(integer :min 0) input)

   will return the integer value from strin if it is >0, or signal and
   invalid-input error if not and::

     (parse-input '(member :type integer :set (1 5 7)) input)

   will return it only if it has a value in the set.

   The `use-value` restart may be used to provide substitute value if the
   input is invalid.

generic function **format-output** `specification value &key &allow-other-keys => string`
   Return a string representation of value formatted
   according to a specification. If specification is a list the first
   element specifies the actual validation method and the rest of the
   list are passed as keyword arguments to the specific method e.g.::

    (format-output '(date :fmt :rfc2822) (get-universal-time))
    >"Mon, 10 Jul 2006 15:43:45 +00"

generic function **equivalent** `specification input reference &key &allow-other-keys => boolean`
  Return true if the input and reference values can be consider
  equivalent according to the specification. The default is to test
  using **equal**.

generic function **parse-options** `spec options-list &optional allow-other-options => options`
  Parse an option list (alist of names and strings to be parsed)
  against a specification. The specification is a list of entries each
  of which lists the name, and optionally the type specification (to
  be used by **parse-input**) and the default value to be used if there
  is no entry in the options-list. The
  output is an alist of names and the parsed or default values. Options in
  `options-list` not in spec are not returned and will signal a correctable
  `unknown-option` error unless `allow-other-options` is true.

generic function **parse-arguments** `spec argument-string &optional allow-spaces => arguments`
  Parse a string of whitespace delimited arguments according to spec.
  The specification is a list of entries each
  of which lists the name, and optionally the type  specification (to
  be used by **parse-input**) and default values. The
  output is an alist of variable names and parsed values.
  If allow-spaces is true, last element can contain spaces
  (i.e. trailing spaces are not trimmed).

formatter function **eng** `os arg &optional colon-p at-p d padchar exponentchar`
  Formatter which outputs its numerical argument `arg` in engineering format
  to stream `os`.
  It takes arguments `d,padchar,exponentchar` where
  `d` is the number of decimal places to display after the decimal point
  `padchar` is the character to pad the start of the number
  `exponentchar` is the character to use to display between radix and exponent
  It also takes the : modifier which will cause it to output the exponent
  as an SI units prefix rather than a number.

  e.g. `(format nil \"~/eng/\" 35000) => \"35.00e+3\"`

formatter function **date** `os utime &optional colon-p at-p precision 6 timezone`
  Formatter which formats a universal time for output as a date and time

  Modifiers:

  - os: an output stream designator
  - arg: a universal time
  - colon-p: a generalised boolean (default false).
             If true use month and day names in date
  - at-p: a generalised boolean (default false) - if true print in yyyy-mm-dd
          (sortable) format rather than dd-mm-yyy
  - precision: what precision to print it to. 6 is to the second,
             7 includes timezone, a negative number counts backward.
  - timezone: an integer (default `*timezone*`).
            If nil no timezone used and time is in current timezone
            adjusted for daylight saving time.
        
  e.g. `(format nil \"~/date/\" (get-universal-time)) => \"19-03-2009 08:30\""`

function **join-strings** `strings &optional (separator #\space) => string`
  Return a new string by joining together the list of  `strings`,
  separating each string with a `separator` character or string

function **split-string** `string &key count delimiter remove-empty-subseqs => list`
  Split `string` along whitespace as defined by the sequence `delimiter`.
  Whitespace which causes a split is elided from the result.  The whole
  string will be split, unless `max` is provided, in which case the
  string will be split into this number of tokens at most, the last one
  containing the whole rest of the given `string`. If
  `remove-empty-subseqs` is true zero length entries are removed. This
  is similar to `split-sequence` however it only takes a string input and
  the delimiter may be a string.

Type Specifications
===================

A type specification is an S-expression composed of a symbol
specifying the particular conversion and a keyword argument list of
qualifiers. Specific methods of **parse-input** and **format-output**
are specialised on the conversion type symbol and take the remainder
of the S-expression as an argument list. Adding your own conversions
is simply a matter of providing appropriately specialised
methods. The intended semantics are that the if the output from
**format-output** is read back in using **parse-input** with thye same
type specifications then an equivalent object should result.

Many conversions take the `nil-allowed` argument which
convert an empty or all whitespace string to nil corresponding to a
null input, otherwise an empty string is considered invalid input.
Methods specialisations are provided for the following types:


**boolean** `&key`
  Converts typical user boolean values (e.g. "TRUE", "Y",  "0") into a
  boolean type. On output "TRUE" and "FALSE" are used.

**bit-vector** `&key`
  Converts between a string of 0 and 1s and a bit vector.

**date** `&key nil-allowed zone fmt` Uses the `parse-time` library of
  Jim Healy and Daniel Barlow to convert to internal universal time in
  specified timezone `zone` which to defaults to special variable
  `*timezone*` for output but to `nil` for parsing input. If `zone` is
  nil the time will be in the current timezone allowing for local
  daylight savings time - otherwise it is in the specified timezone,
  which will be written out.

  `fmt` is a keyword specifying the output format to be used as
  follows.

   A stand alone formatter of the same name is also provided.
  
  :RFC2822   - output as per RFC2822 for internet messages
  :SHORT     - output in a shorter format (same as :ISO)
  :TIME-ONLY - outputs time as hh:mm:ss
  :DATE-ONLY - outputs date as dd-mm-yyyy
  :ISO       - output as per ISO 8602 (default)

**dimensional-parameter** `&key padchar decimal-places tol`
  Converts between a string which includes units and normal scaling
  suffixes and a cons of the numerical value and the base units
  string. `padchar` and `decimal-places` are as per **eng**.

  A dimensional comparator is equivalent if the numerical values and
  the units are equivalent.
 
**eng** `&key units padchar decimal-places`
  Parse a number suffix
  with units. The standard engineering prefixes are assumed for the
  units (but with 'u' instead of 'µ'). The appropriatly scaled
  floating point value is returned and if the `units`. If `units` is a
  string then the input units suffix must match. On output the number
  will be scaled and the appropriate engineering prefix used.
  A general purpose formatter of the same name is also provided.

**filename** `&key if-invalid replacement`
  Return a safe filename from a string path value.
  May return an error or replace invalid characters with the specified
  replacement letter (default '-');

**headers** `&key stream skip-blanks-p field-specifications
  preserve-newlines-p termination-test if-no-specification`
  Parse or format internet message style headers. `parse-input` takes
  either a string or stream as the input value. 

  `field-specifications`
  is either an a-list by field name of giving the parse type
  specification to be applied recursively for that field or a function
  which returns the parse type specification and a `present-p` values
  in the usual way. `if-no-specification` specifies either a type
  specification to be used if the field is not found in
  `field-specifications`, `:error` for this case to be flagged as an
  error or `:ignore` to ignore fields without specifications.
  If defaults to `nil` i.e. value is passed through as a string
  without parsing.

  `skip-blanks-p` will allow the parser to skip leading blank lines on
  the input. `termination-test` is a test function which of one
  argument (a string - a line) which should return true if the
  argument terminates the headers - default tests for a zero length
  line. If `preserve-newlines-p` is true then continuation lines will
  keep their newline characters, otherwise the newlines and first
  continuation character are removed.

  `format-output` will write its output to `stream` if it is given,
  otherwise it will return a string containing the output headers.   

**integer** `&key min max nil-allowed radix format`
  Converts to an integer between `min` and `max` (inclusive, and if
  specified). `radix` specified the base (in the usual way). `format`
  specifies the format control string to be used for output.

**list** `&key separator type min-length max-length`
  Return a list of objects delimited by the given `separator`
  string. Each member is recursively checked the nested type
  (another type specification). If specified `min-length` and
  `max-length` specify the required length bounds. The type
  specification may be a list of type specifications applied to each
  element in turn or a single type specification applied to all
  elements (note there is an ambiguity if you specify a list of one
  symbol - in this it is taken as a conversion for the first element only).

**member** `&key type set test  key`
  Recursively uses `type` to convert string to internal object which
  is then checked for membership of the list `set` using `key` and
  `test`(default is equal allowing for string tests).

**nil** `&key`
  Return string unchanged.

**number** `&key min max nil-allowed format radix tol`
  Converts to a general number between `min` and `max` (inclusive, and if
  specified). `radix`
  specified the base (in the usual way). `format` specifies the format
  control string to be used for output. The `parse-number` library of
  Matthew Danish is used to do the conversion.

  `tol` is the tolerance to be used for **equivalence** testing - it
  can either be a multiplier applied to the reference value or a
  function of two arguments - the input and the reference value.

**pathname** `&key must-exist wild-allowed nil-allowed`
  Convert input to a pathname. If `wild-allowed` is true then the
  pathname is allowed to be wild, otherwise if `must-exist` is true
  then the pathname must correspond to an existing file (checked using
  probe-file.  

**pathnames** `&key must-exist wild-allowed nil-allowed`
  Return a list of pathnames delimited by ':', each checked as for **pathname**

**read** `&key multiplep type package`
  Uses the lisp reader with the current package set to
  `package`. `type` is a Common Lisp type against which the read
  object(s) is checked. If `multiplep` is true then read will be
  continually called until all characters are used up and the results
  are returned as a list. On output, if `multiplep` is true list of
  objects are separated by a space and written readably. 

**roman**
  Convert between roman numerals (up to 4000) and an integer

**string** `&key strip-return nil-allowed min-word-count max-word-count min-length max-length`
  Validates that the string is between `min-length` and `max-length`
  characters long (inclusive, and if specified) and the word count is
  between `min-word-count` and `max-word-count`. 
  Whitespace is trimmed from the returned string, and if
  `strip-return` is specified the RETURN characters are stripped from
  the string (useful when handling input from http forms).

**symbol** `&key nil-allowed package convert`
  Returns a symbol from the string interned into `package` (default
  is the keyword package). `conversion` is a function applied to the
  string before it is interned (default identity) which may for
  example be used to change case or map special characters.

**time-period** `&key`
  A time period in hours, minutes and (optionally) seconds is
  converted into an integer number of seconds. ':' is used as the
  delimiter between fields.

Conditions and Restarts
=======================

**invalid-format** 
  is signalled if the input doesn't meet the type specification. It has
  readers `invalid-format-value` and `invalid-format-reason`.

**use-value** 
  restart may be invoked to specify a result to be used if
  invalid-input is signalled.

**use-default**
  This restart is available for **parse-options** and
  **parse-arguments** and will result in a default specified value
  being used.


Acknowledgements
================

Matthew Danish for the parse-number library used and enclosed with
this.

Daniel Barlow and Jim Healey for the parse-time library.



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 data-format-validation

Maintainer

Dr. John A.R. Williams

Author

Dr. John A.R. Williams

License

GPL v3

Description

Validation and conversion between user and internal data.

Version

0.2.0

Dependency

cl-ppcre

Source

data-format-validation.asd (file)

Components

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

3 Files

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


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

3.1 Lisp


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

3.1.1 data-format-validation.asd

Location

data-format-validation.asd

Systems

data-format-validation (system)


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

3.1.2 data-format-validation/defpackage.lisp

Parent

data-format-validation (system)

Location

defpackage.lisp

Packages

data-format-validation


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

3.1.3 data-format-validation/validation.lisp

Dependencies
Parent

data-format-validation (system)

Location

validation.lisp

Exported Definitions
Internal Definitions

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

3.1.4 data-format-validation/parse-time.lisp

Dependency

defpackage.lisp (file)

Parent

data-format-validation (system)

Location

parse-time.lisp

Internal Definitions

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

3.1.5 data-format-validation/parse-number.lisp

Dependency

defpackage.lisp (file)

Parent

data-format-validation (system)

Location

parse-number.lisp

Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 data-format-validation

Exports API for validation and conversion of user data to internal types and back again.

Source

defpackage.lisp (file)

Nickname

dfv

Use List
Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Special variables

Special Variable: *timezone*

Default timezone for date handling

Package

data-format-validation

Source

validation.lisp (file)


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

5.1.2 Functions

Function: date OS UTIME &optional COLON-P AT-P PRECISION TIMEZONE

Formatter which formats a universal time for output as a date and time

Modifiers:

- os: an output stream designator
- arg: a universal time
- colon-p: a generalised boolean (default false).
If true use month and day names in date
- at-p: a generalised boolean (default false) - if true print in yyyy-mm-dd (sortable) format rather than dd-mm-yyy
- precision: what precision to print it to. 6 is to the second,
7 includes timezone, a negative number counts backward.
- timezone: an integer (default nil).
If nil no timezone used and time is in current timezone adjusted for daylight saving time.

Result:

nil

Examples:

(format nil "~/date/" (get-universal-time)) => "19-03-2009 08:30"

Package

data-format-validation

Source

validation.lisp (file)

Function: duration OS SECONDS &optional COLON-P AT-P PRECISION WIDTH
Package

data-format-validation

Source

validation.lisp (file)

Function: eng OS ARG &optional COLON-P AT-P D PADCHAR EXPONENTCHAR

Formatter which outputs its numerical argument ‘arg‘ in engineering format to stream ‘os‘.
It takes arguments d,padchar,exponentchar where
d is the number of decimal places to display after the decimal point padchar is the character to pad the start of the number
exponentchar is the character to use to display between radix and exponent It also takes the : modifier which will cause it to output the exponent as an SI units prefix rather than a number.

Arguments:

- ‘os‘: an output stream designator
- ‘arg‘: a number
- ‘colon-p‘: a generalised boolean (default false)
- ‘at-p‘: a generalised boolean (default false) - if set right align field - ‘d‘: an integer (default 2)
- ‘padchar‘: a character (default ‘space‘)
- ‘exponentchar‘: a character (default ‘e‘))

Result:

nil

Examples:

‘(format nil "~/eng/" 35000) => "35.00e+3"‘

Package

data-format-validation

Source

validation.lisp (file)

Function: join-strings STRINGS &optional SEPARATOR

Return a new string by joining together the STRINGS, separating each string with a SEPARATOR character or string

Package

data-format-validation

Source

validation.lisp (file)

Function: parse-arguments SPEC ARGUMENT-STRING &optional ALLOW-SPACES

Parse a string of whitespace delimited arguments according to spec. The specification is a list of entries each
of which lists the name, and optionally type and default values. The output is an alist of variable names and parsed values.
If allow-spaces is true, last element can contain spaces

Package

data-format-validation

Source

validation.lisp (file)

Function: parse-options SPEC OPTIONS-LIST &optional ALLOW-OTHER-OPTIONS

Parse an option list (alist of names and strings to be parsed) against a specification. The specification is a list of entries each of which lists the name, and optionally type and default values. The output is an alist of variable names and parsed values. Options in options-list not in spec are not returned and will signal an error unless allow-other-options is true

Package

data-format-validation

Source

validation.lisp (file)

Function: split-string STRING &key COUNT DELIMITER REMOVE-EMPTY-SUBSEQS

Split ‘string’ along whitespace as defined by the sequence ‘ws’. Whitespace which causes a split is elided from the result. The whole string will be split, unless ‘max’ is provided, in which case the string will be split into ‘max’ tokens at most, the last one containing the whole rest of the given ‘string’, if any.

Package

data-format-validation

Source

validation.lisp (file)


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

5.1.3 Generic functions

Generic Function: equivalent SPECIFICATION INPUT REFERENCE &key TEST TOL &allow-other-keys

Returns true if the parsed value input is
equivalent (equals) the reference value according to the stype specification. If specification is a list the first element specifies the actual validation method and the rest of the list are passed as keyword arguments to the specific method.

Package

data-format-validation

Source

validation.lisp (file)

Methods
Method: equivalent (SPEC (eql dimensional-parameter)) INPUT REFERENCE &rest REST
Method: equivalent (SPEC list) INPUT REFERENCE &rest REST
Method: equivalent SPEC INPUT REFERENCE &key TEST &allow-other-keys
Method: equivalent (SPEC (eql number)) INPUT REFERENCE &key TOL &allow-other-keys
Generic Function: format-output SPECIFICATION VALUE &key PLACES %-P MULT PADCHAR DECIMAL-PLACES NIL-ALLOWED UNITS FIELD-SPECIFICATIONS IF-NO-SPECIFICATION STREAM PRESERVE-NEWLINES-P TYPE SEPARATOR MULTIPLEP PACKAGE FORMAT RADIX FMT ZONE IF-NIL &allow-other-keys

Return a string representation of value formatted
according to a specification. If specification is a list the first element specifies the actual validation method and the rest of the list are passed as keyword arguments to the specific method e.g.

(format-output ’(date :fmt :rfc2822) (get-universal-time))

>"Mon, 10 Jul 2006 15:43:45 +00"

Package

data-format-validation

Source

validation.lisp (file)

Methods
Method: format-output (SPEC (eql percentage)) NUM &key PLACES %-P MULT

Return a percentage value formatted for user output (default 0 places)

Method: format-output (SPEC (eql dimensional-parameter)) VALUE &key PADCHAR DECIMAL-PLACES NIL-ALLOWED &allow-other-keys

Output in engineering style with units. If units is a string then the output will contain that unit and the appropriate suffix. If t only the suffix is output. If nil no units or suffix is output

Method: format-output (SPEC (eql bit-vector)) (INPUT bit-vector) &key &allow-other-keys
Method: format-output (SPEC (eql roman)) (N integer) &key &allow-other-keys

convert integer to Roman numeral

Method: format-output (SPEC (eql eng)) (VALUE number) &key UNITS PADCHAR DECIMAL-PLACES &allow-other-keys

Output in engineering style with units. If units is a string then the output will contain that unit and the appropriate suffix. If t only the suffix is output. If nil no units or suffix is output

Method: format-output (SPEC (eql headers)) (HEADERS list) &key FIELD-SPECIFICATIONS IF-NO-SPECIFICATION STREAM PRESERVE-NEWLINES-P
Method: format-output (SPEC (eql time-period)) (VALUE number) &key &allow-other-keys
Method: format-output (SPEC (eql member)) OUTPUT &key TYPE
Method: format-output (SPEC (eql list)) OUTPUT &key TYPE SEPARATOR
Method: format-output (SPEC (eql read)) OUTPUT &key MULTIPLEP PACKAGE

Parse input using read. If multiple is true will read until finsihed, returning a list of values.

Method: format-output (SPEC (eql integer)) OUTPUT &key FORMAT &allow-other-keys
Method: format-output (SPEC (eql number)) OUTPUT &key RADIX FORMAT &allow-other-keys
Method: format-output (SPEC (eql date)) OUTPUT &key FMT ZONE IF-NIL &allow-other-keys
Method: format-output (SPEC (eql nil)) OUTPUT &key &allow-other-keys

No validation - just output value

Method: format-output (SPEC function) OUTPUT &key &allow-other-keys
Method: format-output (SPEC string) OUTPUT &key &allow-other-keys
Method: format-output SPEC OUTPUT &key &allow-other-keys

No validation - just output value

Method: format-output (SPEC list) OUTPUT &rest REST

Dispatch a list spec to appropriate method

Method: format-output (SPEC (eql separated)) (VALUE list) &key SEPARATOR TYPE
Method: format-output (SPEC (eql boolean)) INPUT &key FMT &allow-other-keys
Generic Function: invalid-format-reason CONDITION
Package

data-format-validation

Methods
Method: invalid-format-reason (CONDITION invalid-format)
Source

validation.lisp (file)

Generic Function: invalid-format-type CONDITION
Package

data-format-validation

Methods
Method: invalid-format-type (CONDITION invalid-format)
Source

validation.lisp (file)

Generic Function: invalid-format-value CONDITION
Package

data-format-validation

Methods
Method: invalid-format-value (CONDITION invalid-format)
Source

validation.lisp (file)

Generic Function: parse-input SPECIFICATION INPUT &key MIN MAX NIL-ALLOWED UNITS SKIP-BLANKS-P FIELD-SPECIFICATIONS PRESERVE-NEWLINES-P TERMINATION-TEST IF-NO-SPECIFICATION SEPARATOR TYPE PACKAGE MULTIPLEP ZONE PATTERNS MIN-LENGTH MAX-LENGTH IF-INVALID REPLACEMENT MUST-EXIST WILD-ALLOWED SET TEST KEY CONVERT STRIP-RETURN MIN-WORD-COUNT MAX-WORD-COUNT FORMAT RADIX RATIONAL-AS-FLOAT-P COERCE-TO &allow-other-keys

Validate and parse user input according to
specification, returning the validated object. Throws an invalid-format condition if input is invalid. If specification is a list the first element specifies the actual validation method and the rest of the list are passed as keyword arguments to the specific method e.g.

(parse-input ’(integer :min 0) input)

will return the integer value from string if it is >0, or signal and invalid-format condition if not.

(parse-input ’(member :type integer :set (1 5 7)) input)

will return it only if it has a value in the set.

The use-value restart may be used to provide substitute value if the input is invalid.

Package

data-format-validation

Source

validation.lisp (file)

Methods
Method: parse-input (SPEC (eql percentage)) (VALUE string) &key MIN MAX NIL-ALLOWED &allow-other-keys
Method: parse-input (SPEC (eql dimensional-parameter)) (VALUE string) &key &allow-other-keys
Method: parse-input (SPEC (eql bit-vector)) (INPUT string) &key &allow-other-keys
Method: parse-input (SPEC (eql roman)) (S string) &key &allow-other-keys

Convert roman numeral to integer

Method: parse-input (SPEC (eql eng)) (VALUE string) &key UNITS &allow-other-keys
Method: parse-input (SPEC (eql headers)) (IS stream) &key SKIP-BLANKS-P FIELD-SPECIFICATIONS PRESERVE-NEWLINES-P TERMINATION-TEST IF-NO-SPECIFICATION &allow-other-keys
Method: parse-input (SPEC (eql headers)) (P pathname) &rest REST
Method: parse-input (SPEC (eql headers)) (S string) &rest REST
Method: parse-input (SPEC (eql time-period)) (VALUE string) &key &allow-other-keys

A time period in hours, minutes and (optionally) seconds

Method: parse-input (SPEC (eql separated)) (VALUE sequence) &key SEPARATOR TYPE
Method: parse-input (SPEC (eql eval)) (VALUE string) &key TYPE PACKAGE
Method: parse-input (SPEC (eql read)) (VALUE string) &key MULTIPLEP TYPE PACKAGE

Parse input using read. If multiple is true will read until finished, returning a list of values. If type is set, then returned value(s) must be of this type

Method: parse-input (SPEC (eql date)) (INPUT string) &key NIL-ALLOWED ZONE PATTERNS
Method: parse-input (SPEC (eql list)) INPUT &key SEPARATOR TYPE MIN-LENGTH MAX-LENGTH

Validates that a list of given of between min-length and max-length in length. Each member of list is validated against type

Method: parse-input (SPEC (eql filename)) VALUE &key IF-INVALID REPLACEMENT

Return a safe filename from a string path value. May return an error or replace invalid characters.

Method: parse-input (SPEC (eql pathnames)) (INPUT string) &key MUST-EXIST WILD-ALLOWED NIL-ALLOWED
Method: parse-input (SPEC (eql pathname)) (INPUT string) &key MUST-EXIST WILD-ALLOWED NIL-ALLOWED
Method: parse-input (SPEC (eql member)) INPUT &key TYPE SET TEST KEY
Method: parse-input (SPEC (eql symbol)) (INPUT string) &key NIL-ALLOWED PACKAGE CONVERT
Method: parse-input (SPEC (eql string)) S &key STRIP-RETURN NIL-ALLOWED MIN-WORD-COUNT MAX-WORD-COUNT MIN-LENGTH MAX-LENGTH
Method: parse-input (SPEC (eql number)) (INPUT string) &key MIN MAX NIL-ALLOWED FORMAT RADIX RATIONAL-AS-FLOAT-P COERCE-TO

Real, integer or rational numbers

Method: parse-input (SPEC (eql integer)) (INPUT string) &key MIN MAX NIL-ALLOWED RADIX
Method: parse-input (SPEC (eql boolean)) INPUT &key &allow-other-keys
Method: parse-input (SPEC function) INPUT &key &allow-other-keys

Function - call it with data

Method: parse-input (SPEC (eql nil)) INPUT &key &allow-other-keys

No validation - just return string

Method: parse-input (SPEC list) INPUT &rest REST

Dispatch a list spec to appropriate method

Method: parse-input (SPECIFICATION symbol) INPUT &rest ARGS around

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

5.1.4 Conditions

Condition: invalid-format ()
Package

data-format-validation

Source

validation.lisp (file)

Direct superclasses

condition (condition)

Direct methods
Direct slots
Slot: type

The type specification

Initargs

:type

Initform

(quote nil)

Readers

invalid-format-type (generic function)

Slot: value

The value input

Initargs

:value

Initform

(quote nil)

Readers

invalid-format-value (generic function)

Slot: reason

Textual description of reason value is invalid.

Initargs

:reason

Initform

(quote nil)

Readers

invalid-format-reason (generic function)


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

5.2 Internal definitions


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

5.2.1 Special variables

Special Variable: *default-date-time-patterns*
Package

data-format-validation

Source

parse-time.lisp (file)

Special Variable: *error-on-mismatch*

If t, an error will be signalled if parse-time is unable to determine the time/date format of the string.

Package

data-format-validation

Source

parse-time.lisp (file)

Special Variable: *http-date-time-patterns*
Package

data-format-validation

Source

parse-time.lisp (file)

Special Variable: *month-strings*
Package

data-format-validation

Source

parse-time.lisp (file)

Special Variable: *special-strings*
Package

data-format-validation

Source

parse-time.lisp (file)

Special Variable: *weekday-strings*
Package

data-format-validation

Source

parse-time.lisp (file)

Special Variable: *white-space-characters*
Package

data-format-validation

Source

parse-number.lisp (file)

Special Variable: *zone-strings*
Package

data-format-validation

Source

parse-time.lisp (file)

Special Variable: +engineering-units+
Package

data-format-validation

Source

validation.lisp (file)

Special Variable: +month-names+

The names of the months.

Package

data-format-validation

Source

validation.lisp (file)

Special Variable: +roman-numeral-map+
Package

data-format-validation

Source

validation.lisp (file)

Special Variable: +time-zones+

The string representations of the time zones.

Package

data-format-validation

Source

validation.lisp (file)

Special Variable: +week-days+

The names of the days of the week.

Package

data-format-validation

Source

validation.lisp (file)

Special Variable: +ws+

Bag of white space delimiter characters

Package

data-format-validation

Source

validation.lisp (file)

Special Variable: date-dividers
Package

data-format-validation

Source

parse-time.lisp (file)

Special Variable: month-table-size
Package

data-format-validation

Source

parse-time.lisp (file)

Special Variable: special-table-size
Package

data-format-validation

Source

parse-time.lisp (file)

Special Variable: time-dividers
Package

data-format-validation

Source

parse-time.lisp (file)

Special Variable: weekday-table-size
Package

data-format-validation

Source

parse-time.lisp (file)

Special Variable: whitespace-chars
Package

data-format-validation

Source

parse-time.lisp (file)

Special Variable: zone-table-size
Package

data-format-validation

Source

parse-time.lisp (file)


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

5.2.2 Macros

Macro: hashlist LIST TABLE
Package

data-format-validation

Source

parse-time.lisp (file)

Macro: invalid-format-error TYPE VALUE &rest REASON

Generate an invalid-format error for given value using reason

Package

data-format-validation

Source

validation.lisp (file)


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

5.2.3 Functions

Function: am-pm STRING
Package

data-format-validation

Source

parse-time.lisp (file)

Function: convert-to-unitime PARSED-VALUES
Package

data-format-validation

Source

parse-time.lisp (file)

Function: copy-decoded-time INSTANCE
Package

data-format-validation

Source

parse-time.lisp (file)

Function: date-divider CHARACTER
Package

data-format-validation

Source

parse-time.lisp (file)

Function: day NUMBER
Package

data-format-validation

Source

parse-time.lisp (file)

Function: deal-with-am-pm FORM-VALUE PARSED-VALUES
Package

data-format-validation

Source

parse-time.lisp (file)

Function: deal-with-izone FORM-VALUE PARSED-VALUES
Package

data-format-validation

Source

parse-time.lisp (file)

Function: deal-with-noon-midn FORM-VALUE PARSED-VALUES
Package

data-format-validation

Source

parse-time.lisp (file)

Function: decoded-time-day INSTANCE
Function: (setf decoded-time-day) VALUE INSTANCE
Package

data-format-validation

Source

parse-time.lisp (file)

Function: decoded-time-dotw INSTANCE
Function: (setf decoded-time-dotw) VALUE INSTANCE
Package

data-format-validation

Source

parse-time.lisp (file)

Function: decoded-time-hour INSTANCE
Function: (setf decoded-time-hour) VALUE INSTANCE
Package

data-format-validation

Source

parse-time.lisp (file)

Function: decoded-time-minute INSTANCE
Function: (setf decoded-time-minute) VALUE INSTANCE
Package

data-format-validation

Source

parse-time.lisp (file)

Function: decoded-time-month INSTANCE
Function: (setf decoded-time-month) VALUE INSTANCE
Package

data-format-validation

Source

parse-time.lisp (file)

Function: decoded-time-p OBJECT
Package

data-format-validation

Source

parse-time.lisp (file)

Function: decoded-time-second INSTANCE
Function: (setf decoded-time-second) VALUE INSTANCE
Package

data-format-validation

Source

parse-time.lisp (file)

Function: decoded-time-year INSTANCE
Function: (setf decoded-time-year) VALUE INSTANCE
Package

data-format-validation

Source

parse-time.lisp (file)

Function: decoded-time-zone INSTANCE
Function: (setf decoded-time-zone) VALUE INSTANCE
Package

data-format-validation

Source

parse-time.lisp (file)

Function: decompose-string STRING &key START END RADIX
Package

data-format-validation

Source

parse-time.lisp (file)

Function: format-time OUT UTIME &key FMT TIMEZONE

Formats a universal time for output.

OUT controls where the result will go. If OUT is T, then the output is sent to the standard output stream. If it is NIL, then the output is returned in a string as the value of the call. Otherwise, OUT must be a stream to which the output will be sent.

UTIME is the universal time to be output (default is current time)
TZ is the time zone default will give local time.

FMT is a keyword symbol specifying which output format is used as follows :RFC2822 - output as per RFC2822 for internet messages
:SHORT - output in a shorter format (same as :ISO)
:TIME-ONLY - outputs time as hh:mm:ss
:DATE-ONLY - outputs date as dd-mm-yyyy
:ISO - output as per ISO 8602

Package

data-format-validation

Source

validation.lisp (file)

Function: hour NUMBER
Package

data-format-validation

Source

parse-time.lisp (file)

Function: is-nil-string STRING
Package

data-format-validation

Source

validation.lisp (file)

Function: izone THING
Package

data-format-validation

Source

parse-time.lisp (file)

Function: lookup-field NAME FIELD-SPECIFICATIONS
Package

data-format-validation

Source

validation.lisp (file)

Function: make-decoded-time &key (SECOND SECOND) (MINUTE MINUTE) (HOUR HOUR) (DAY DAY) (MONTH MONTH) (YEAR YEAR) (ZONE ZONE) (DOTW DOTW)
Package

data-format-validation

Source

parse-time.lisp (file)

Function: make-default-time DEF-SEC DEF-MIN DEF-HOUR DEF-DAY DEF-MON DEF-YEAR DEF-ZONE DEF-DOTW
Package

data-format-validation

Source

parse-time.lisp (file)

Function: match-pattern PATTERN DATUM DATUM-LENGTH
Package

data-format-validation

Source

parse-time.lisp (file)

Function: match-pattern-element PATTERN-ELEMENT DATUM-ELEMENT
Package

data-format-validation

Source

parse-time.lisp (file)

Function: match-substring SUBSTRING
Package

data-format-validation

Source

parse-time.lisp (file)

Function: minute NUMBER
Package

data-format-validation

Source

parse-time.lisp (file)

Function: month THING
Package

data-format-validation

Source

parse-time.lisp (file)

Function: noon-midn STRING
Package

data-format-validation

Source

parse-time.lisp (file)

Function: now PARSED-VALUES
Package

data-format-validation

Source

parse-time.lisp (file)

Function: number-value X
Package

data-format-validation

Source

parse-number.lisp (file)

Function: parse-integer-and-places STRING START END &key RADIX
Package

data-format-validation

Source

parse-number.lisp (file)

Function: parse-integers STRING START END SPLITTING-POINTS &key RADIX
Package

data-format-validation

Source

parse-number.lisp (file)

Function: parse-number STRING &key START END RADIX

Given a string, and start, end, and radix parameters, produce a number according to the syntax definitions in the Common Lisp Hyperspec.

Package

data-format-validation

Source

parse-number.lisp (file)

Function: parse-positive-real-number STRING &key START END RADIX

Given a string, and start, end, and radix parameters, produce a number according to the syntax definitions in the Common Lisp Hyperspec – except for complex numbers and negative numbers.

Package

data-format-validation

Source

parse-number.lisp (file)

Function: parse-real-number STRING &key START END RADIX

Given a string, and start, end, and radix parameters, produce a number according to the syntax definitions in the Common Lisp Hyperspec – except for complex numbers.

Package

data-format-validation

Source

parse-number.lisp (file)

Function: parse-time TIME-STRING &key START END ERROR-ON-MISMATCH PATTERNS DEFAULT-SECONDS DEFAULT-MINUTES DEFAULT-HOURS DEFAULT-DAY DEFAULT-MONTH DEFAULT-YEAR DEFAULT-ZONE DEFAULT-WEEKDAY

Tries very hard to make sense out of the argument time-string and returns a single integer representing the universal time if successful. If not, it returns nil. If the :error-on-mismatch keyword is true, parse-time will signal an error instead of returning nil. Default values for each part of the time/date can be specified by the appropriate :default- keyword. These keywords can be given a numeric value or the keyword :current to set them to the current value. The default-default values are 00:00:00 on the current date, current time-zone.

Package

data-format-validation

Source

parse-time.lisp (file)

Function: places X
Package

data-format-validation

Source

parse-number.lisp (file)

Function: secondp NUMBER
Package

data-format-validation

Source

parse-time.lisp (file)

Function: set-current-value VALUES-STRUCTURE &key TIME DATE ZONE
Package

data-format-validation

Source

parse-time.lisp (file)

Function: set-time-values STRING-FORM PARSED-VALUES
Package

data-format-validation

Source

parse-time.lisp (file)

Function: special-string-p STRING
Package

data-format-validation

Source

parse-time.lisp (file)

Function: time-divider CHARACTER
Package

data-format-validation

Source

parse-time.lisp (file)

Function: today PARSED-VALUES
Package

data-format-validation

Source

parse-time.lisp (file)

Function: tomorrow PARSED-VALUES
Package

data-format-validation

Source

parse-time.lisp (file)

Function: weekday STRING
Package

data-format-validation

Source

parse-time.lisp (file)

Function: white-space-p X
Package

data-format-validation

Source

parse-number.lisp (file)

Function: year NUMBER
Package

data-format-validation

Source

parse-time.lisp (file)

Function: yesterday PARSED-VALUES
Package

data-format-validation

Source

parse-time.lisp (file)

Function: zone THING
Package

data-format-validation

Source

parse-time.lisp (file)


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

5.2.4 Generic functions

Generic Function: reason CONDITION
Package

data-format-validation

Methods
Method: reason (CONDITION invalid-number)
Source

parse-number.lisp (file)

Generic Function: value CONDITION
Package

data-format-validation

Methods
Method: value (CONDITION invalid-number)
Source

parse-number.lisp (file)


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

5.2.5 Conditions

Condition: invalid-number ()
Package

data-format-validation

Source

parse-number.lisp (file)

Direct superclasses

condition (condition)

Direct methods
Direct slots
Slot: value
Initargs

:value

Initform

(quote nil)

Readers

value (generic function)

Slot: reason
Initargs

:reason

Initform

(quote "not specified")

Readers

reason (generic function)


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

5.2.6 Structures

Structure: decoded-time ()
Package

data-format-validation

Source

parse-time.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: second
Type

integer

Initform

0

Readers

decoded-time-second (function)

Writers

(setf decoded-time-second) (function)

Slot: minute
Type

integer

Initform

0

Readers

decoded-time-minute (function)

Writers

(setf decoded-time-minute) (function)

Slot: hour
Type

integer

Initform

0

Readers

decoded-time-hour (function)

Writers

(setf decoded-time-hour) (function)

Slot: day
Type

integer

Initform

1

Readers

decoded-time-day (function)

Writers

(setf decoded-time-day) (function)

Slot: month
Type

integer

Initform

1

Readers

decoded-time-month (function)

Writers

(setf decoded-time-month) (function)

Slot: year
Type

integer

Initform

1900

Readers

decoded-time-year (function)

Writers

(setf decoded-time-year) (function)

Slot: zone
Type

(or rational null)

Readers

decoded-time-zone (function)

Writers

(setf decoded-time-zone) (function)

Slot: dotw
Type

integer

Initform

0

Readers

decoded-time-dotw (function)

Writers

(setf decoded-time-dotw) (function)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   D   F   L  
Index Entry  Section

D
data-format-validation.asd: The data-format-validation<dot>asd file
data-format-validation/defpackage.lisp: The data-format-validation/defpackage<dot>lisp file
data-format-validation/parse-number.lisp: The data-format-validation/parse-number<dot>lisp file
data-format-validation/parse-time.lisp: The data-format-validation/parse-time<dot>lisp file
data-format-validation/validation.lisp: The data-format-validation/validation<dot>lisp file

F
File, Lisp, data-format-validation.asd: The data-format-validation<dot>asd file
File, Lisp, data-format-validation/defpackage.lisp: The data-format-validation/defpackage<dot>lisp file
File, Lisp, data-format-validation/parse-number.lisp: The data-format-validation/parse-number<dot>lisp file
File, Lisp, data-format-validation/parse-time.lisp: The data-format-validation/parse-time<dot>lisp file
File, Lisp, data-format-validation/validation.lisp: The data-format-validation/validation<dot>lisp file

L
Lisp File, data-format-validation.asd: The data-format-validation<dot>asd file
Lisp File, data-format-validation/defpackage.lisp: The data-format-validation/defpackage<dot>lisp file
Lisp File, data-format-validation/parse-number.lisp: The data-format-validation/parse-number<dot>lisp file
Lisp File, data-format-validation/parse-time.lisp: The data-format-validation/parse-time<dot>lisp file
Lisp File, data-format-validation/validation.lisp: The data-format-validation/validation<dot>lisp file

Jump to:   D   F   L  

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

A.2 Functions

Jump to:   (  
A   C   D   E   F   G   H   I   J   L   M   N   P   R   S   T   V   W   Y   Z  
Index Entry  Section

(
(setf decoded-time-day): Internal functions
(setf decoded-time-dotw): Internal functions
(setf decoded-time-hour): Internal functions
(setf decoded-time-minute): Internal functions
(setf decoded-time-month): Internal functions
(setf decoded-time-second): Internal functions
(setf decoded-time-year): Internal functions
(setf decoded-time-zone): Internal functions

A
am-pm: Internal functions

C
convert-to-unitime: Internal functions
copy-decoded-time: Internal functions

D
date: Exported functions
date-divider: Internal functions
day: Internal functions
deal-with-am-pm: Internal functions
deal-with-izone: Internal functions
deal-with-noon-midn: Internal functions
decoded-time-day: Internal functions
decoded-time-dotw: Internal functions
decoded-time-hour: Internal functions
decoded-time-minute: Internal functions
decoded-time-month: Internal functions
decoded-time-p: Internal functions
decoded-time-second: Internal functions
decoded-time-year: Internal functions
decoded-time-zone: Internal functions
decompose-string: Internal functions
duration: Exported functions

E
eng: Exported functions
equivalent: Exported generic functions
equivalent: Exported generic functions
equivalent: Exported generic functions
equivalent: Exported generic functions
equivalent: Exported generic functions

F
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-output: Exported generic functions
format-time: Internal functions
Function, (setf decoded-time-day): Internal functions
Function, (setf decoded-time-dotw): Internal functions
Function, (setf decoded-time-hour): Internal functions
Function, (setf decoded-time-minute): Internal functions
Function, (setf decoded-time-month): Internal functions
Function, (setf decoded-time-second): Internal functions
Function, (setf decoded-time-year): Internal functions
Function, (setf decoded-time-zone): Internal functions
Function, am-pm: Internal functions
Function, convert-to-unitime: Internal functions
Function, copy-decoded-time: Internal functions
Function, date: Exported functions
Function, date-divider: Internal functions
Function, day: Internal functions
Function, deal-with-am-pm: Internal functions
Function, deal-with-izone: Internal functions
Function, deal-with-noon-midn: Internal functions
Function, decoded-time-day: Internal functions
Function, decoded-time-dotw: Internal functions
Function, decoded-time-hour: Internal functions
Function, decoded-time-minute: Internal functions
Function, decoded-time-month: Internal functions
Function, decoded-time-p: Internal functions
Function, decoded-time-second: Internal functions
Function, decoded-time-year: Internal functions
Function, decoded-time-zone: Internal functions
Function, decompose-string: Internal functions
Function, duration: Exported functions
Function, eng: Exported functions
Function, format-time: Internal functions
Function, hour: Internal functions
Function, is-nil-string: Internal functions
Function, izone: Internal functions
Function, join-strings: Exported functions
Function, lookup-field: Internal functions
Function, make-decoded-time: Internal functions
Function, make-default-time: Internal functions
Function, match-pattern: Internal functions
Function, match-pattern-element: Internal functions
Function, match-substring: Internal functions
Function, minute: Internal functions
Function, month: Internal functions
Function, noon-midn: Internal functions
Function, now: Internal functions
Function, number-value: Internal functions
Function, parse-arguments: Exported functions
Function, parse-integer-and-places: Internal functions
Function, parse-integers: Internal functions
Function, parse-number: Internal functions
Function, parse-options: Exported functions
Function, parse-positive-real-number: Internal functions
Function, parse-real-number: Internal functions
Function, parse-time: Internal functions
Function, places: Internal functions
Function, secondp: Internal functions
Function, set-current-value: Internal functions
Function, set-time-values: Internal functions
Function, special-string-p: Internal functions
Function, split-string: Exported functions
Function, time-divider: Internal functions
Function, today: Internal functions
Function, tomorrow: Internal functions
Function, weekday: Internal functions
Function, white-space-p: Internal functions
Function, year: Internal functions
Function, yesterday: Internal functions
Function, zone: Internal functions

G
Generic Function, equivalent: Exported generic functions
Generic Function, format-output: Exported generic functions
Generic Function, invalid-format-reason: Exported generic functions
Generic Function, invalid-format-type: Exported generic functions
Generic Function, invalid-format-value: Exported generic functions
Generic Function, parse-input: Exported generic functions
Generic Function, reason: Internal generic functions
Generic Function, value: Internal generic functions

H
hashlist: Internal macros
hour: Internal functions

I
invalid-format-error: Internal macros
invalid-format-reason: Exported generic functions
invalid-format-reason: Exported generic functions
invalid-format-type: Exported generic functions
invalid-format-type: Exported generic functions
invalid-format-value: Exported generic functions
invalid-format-value: Exported generic functions
is-nil-string: Internal functions
izone: Internal functions

J
join-strings: Exported functions

L
lookup-field: Internal functions

M
Macro, hashlist: Internal macros
Macro, invalid-format-error: Internal macros
make-decoded-time: Internal functions
make-default-time: Internal functions
match-pattern: Internal functions
match-pattern-element: Internal functions
match-substring: Internal functions
Method, equivalent: Exported generic functions
Method, equivalent: Exported generic functions
Method, equivalent: Exported generic functions
Method, equivalent: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, format-output: Exported generic functions
Method, invalid-format-reason: Exported generic functions
Method, invalid-format-type: Exported generic functions
Method, invalid-format-value: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, parse-input: Exported generic functions
Method, reason: Internal generic functions
Method, value: Internal generic functions
minute: Internal functions
month: Internal functions

N
noon-midn: Internal functions
now: Internal functions
number-value: Internal functions

P
parse-arguments: Exported functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-input: Exported generic functions
parse-integer-and-places: Internal functions
parse-integers: Internal functions
parse-number: Internal functions
parse-options: Exported functions
parse-positive-real-number: Internal functions
parse-real-number: Internal functions
parse-time: Internal functions
places: Internal functions

R
reason: Internal generic functions
reason: Internal generic functions

S
secondp: Internal functions
set-current-value: Internal functions
set-time-values: Internal functions
special-string-p: Internal functions
split-string: Exported functions

T
time-divider: Internal functions
today: Internal functions
tomorrow: Internal functions

V
value: Internal generic functions
value: Internal generic functions

W
weekday: Internal functions
white-space-p: Internal functions

Y
year: Internal functions
yesterday: Internal functions

Z
zone: Internal functions

Jump to:   (  
A   C   D   E   F   G   H   I   J   L   M   N   P   R   S   T   V   W   Y   Z  

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

A.3 Variables

Jump to:   *   +  
D   H   M   R   S   T   V   W   Y   Z  
Index Entry  Section

*
*default-date-time-patterns*: Internal special variables
*error-on-mismatch*: Internal special variables
*http-date-time-patterns*: Internal special variables
*month-strings*: Internal special variables
*special-strings*: Internal special variables
*timezone*: Exported special variables
*weekday-strings*: Internal special variables
*white-space-characters*: Internal special variables
*zone-strings*: Internal special variables

+
+engineering-units+: Internal special variables
+month-names+: Internal special variables
+roman-numeral-map+: Internal special variables
+time-zones+: Internal special variables
+week-days+: Internal special variables
+ws+: Internal special variables

D
date-dividers: Internal special variables
day: Internal structures
dotw: Internal structures

H
hour: Internal structures

M
minute: Internal structures
month: Internal structures
month-table-size: Internal special variables

R
reason: Exported conditions
reason: Internal conditions

S
second: Internal structures
Slot, day: Internal structures
Slot, dotw: Internal structures
Slot, hour: Internal structures
Slot, minute: Internal structures
Slot, month: Internal structures
Slot, reason: Exported conditions
Slot, reason: Internal conditions
Slot, second: Internal structures
Slot, type: Exported conditions
Slot, value: Exported conditions
Slot, value: Internal conditions
Slot, year: Internal structures
Slot, zone: Internal structures
Special Variable, *default-date-time-patterns*: Internal special variables
Special Variable, *error-on-mismatch*: Internal special variables
Special Variable, *http-date-time-patterns*: Internal special variables
Special Variable, *month-strings*: Internal special variables
Special Variable, *special-strings*: Internal special variables
Special Variable, *timezone*: Exported special variables
Special Variable, *weekday-strings*: Internal special variables
Special Variable, *white-space-characters*: Internal special variables
Special Variable, *zone-strings*: Internal special variables
Special Variable, +engineering-units+: Internal special variables
Special Variable, +month-names+: Internal special variables
Special Variable, +roman-numeral-map+: Internal special variables
Special Variable, +time-zones+: Internal special variables
Special Variable, +week-days+: Internal special variables
Special Variable, +ws+: Internal special variables
Special Variable, date-dividers: Internal special variables
Special Variable, month-table-size: Internal special variables
Special Variable, special-table-size: Internal special variables
Special Variable, time-dividers: Internal special variables
Special Variable, weekday-table-size: Internal special variables
Special Variable, whitespace-chars: Internal special variables
Special Variable, zone-table-size: Internal special variables
special-table-size: Internal special variables

T
time-dividers: Internal special variables
type: Exported conditions

V
value: Exported conditions
value: Internal conditions

W
weekday-table-size: Internal special variables
whitespace-chars: Internal special variables

Y
year: Internal structures

Z
zone: Internal structures
zone-table-size: Internal special variables

Jump to:   *   +  
D   H   M   R   S   T   V   W   Y   Z  

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

A.4 Data types

Jump to:   C   D   I   P   S  
Index Entry  Section

C
Condition, invalid-format: Exported conditions
Condition, invalid-number: Internal conditions

D
data-format-validation: The data-format-validation system
data-format-validation: The data-format-validation package
decoded-time: Internal structures

I
invalid-format: Exported conditions
invalid-number: Internal conditions

P
Package, data-format-validation: The data-format-validation package

S
Structure, decoded-time: Internal structures
System, data-format-validation: The data-format-validation system

Jump to:   C   D   I   P   S