The validate-list Reference Manual

Table of Contents

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

The validate-list Reference Manual

This is the validate-list Reference Manual, version 0.0.1, generated automatically by Declt version 3.0 "Montgomery Scott" on Fri Jun 26 12:34:13 2020 GMT+0.


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

1 Introduction

validate-list

This is an attempt at using templates to validate the contents of a list. The idea came because when you parse json from an untrusted source you don't know for certain what has been sent, so the idea is that once parsed you can use a template to check if the parsed data (now a list) conforms to what you want. The primary function is validate-list Which takes in two arguments, the list you wish to validate and a template. Here is the docstring:

"Takes in a LIST that you want to validate, and a TEMPLATE, the TEMPLATE is a list of lists, each list contains keywords and their values (a full list of keys can be found by calling CURRENT-KEYS), if TEMPLATE is 'invalid' then the condition BAD-TEMPLATE-FORM is signalled. Each list within the template represents 1 element in the LIST and is a 'description' of its contents. For example given the template '((:equal "key") (:type string :maxlen 40)) this could be used to validate the list '("key" "abcdeegadfgfsdf") because as the template says, the first item in list is "key" and the second according to the template should be of type 'string and no longer than 40 characters long, which it is not, so this is valid and will return t, if a list fails when checked against the template then this func signals the condition FAILED-TO-VALIDATE, which will contain information about where validation failed. For a list of examples see src/tests.lisp,the invalid templates are marked. In the interests of speed no checks are done to validate the structure of your template before validation happens, you can use 'is-valid-template' as a precursory check to make sure that the template is constructed with valid plists and valid keywords. There is also the possibility that when you try to validate a list where you expect a certain structure and get something else you will get a BAD-TEMPLATE-FORM condition where the template is fine but the list is not, just treat this like the validation failed."

Example templates to validate example lists

;;;trivial example:
(defparameter *test-list1* '("key" "abcdeegadfgfsdf"))
(defparameter *test-template1* '((:equal "key") (:type string :maxlen 40)))

;;;complicated example: 
(defparameter *test-list16*  '("year" 98 ("keyvals" ("USA" 35 "Poland" 55 "UK" 96)
                                          1 2 (2) (6 7) ("oof" "oof" "oof") "abc")))
(defparameter *test-template16* `((:equal "year")(:type integer :or (96 97 98))
                                  ((:or ("keyvals" "time")) 
                                   ,(repeat-pattern 3 '((:type string :maxlen 6 :minlen 2)
                                                        (:type number :between (0 100))))
                                   ,@(repeat-test 2 '(:type number :satisfies (evenp oddp)))
                                   (:type list :length 1)
                                   (:type list :contents (:type number :satisfies (evenp oddp)))
                                   (:type list :minlen 1 :maxlen 5
                                    :contents (:type string :maxlen 5 :equal "oof"))
                                   (:type string :equal "abc"))))
->
((:EQUAL "year") (:TYPE INTEGER :OR (96 97 98))
 ((:OR ("keyvals" "time"))
  ((:TYPE STRING :MAXLEN 6 :MINLEN 2) (:TYPE NUMBER :BETWEEN (0 100))
   (:TYPE STRING :MAXLEN 6 :MINLEN 2) (:TYPE NUMBER :BETWEEN (0 100))
   (:TYPE STRING :MAXLEN 6 :MINLEN 2) (:TYPE NUMBER :BETWEEN (0 100)))
  (:TYPE NUMBER :SATISFIES (EVENP ODDP)) (:TYPE NUMBER :SATISFIES (EVENP ODDP))
  (:TYPE LIST :LENGTH 1)
  (:TYPE LIST :CONTENTS (:TYPE NUMBER :SATISFIES (EVENP ODDP)))
  (:TYPE LIST :MINLEN 1 :MAXLEN 5 :CONTENTS
   (:TYPE STRING :MAXLEN 5 :EQUAL "oof"))
  (:TYPE STRING :EQUAL "abc")))

The helper functions

There are two helper functions repeat-pattern and repeat-test. The purpose of these functions is to help validate a known length and a known pattern, for example if you know that the list is going to be 10 elements long you don't want to write out (:type string) 10 times so you can instead just use one of these functions to do it for you.

VALIDATE-LIST>  (repeat-pattern 3 '((:type string :maxlen 6 :minlen 2)
                                    (:type number :between (0 100))))
((:TYPE STRING :MAXLEN 6 :MINLEN 2) (:TYPE NUMBER :BETWEEN (0 100))
 (:TYPE STRING :MAXLEN 6 :MINLEN 2) (:TYPE NUMBER :BETWEEN (0 100))
 (:TYPE STRING :MAXLEN 6 :MINLEN 2) (:TYPE NUMBER :BETWEEN (0 100)))
VALIDATE-LIST> (repeat-test 3 '(:type number :satisfies (#'evenp #'oddp)))
((:TYPE NUMBER :SATISFIES (#'EVENP #'ODDP))
 (:TYPE NUMBER :SATISFIES (#'EVENP #'ODDP))
 (:TYPE NUMBER :SATISFIES (#'EVENP #'ODDP)))

As you can see in the examples I have used ` and , to control the evaluation of the functions. This is probably the easiest way to do this. It is very important to make sure you use ,@ where necessary as it will be a big cause of BAD-TEMPLATE-FORMAT conditions.

Keyword functions

Here are the keys and what they do (each key takes exactly 1 argument):

Special keys

There is one special key which is an extension of :type and :contents which is used with :type list.

Compiling templates

If you reckon you will be making heavy use of a template you can compile it using compile-template This function takes a template as an argument and returns a compiled function, this compiled function can be used to validate a list simply by calling the function with the list you wish to validate as the only argument. Here is an example:

VALIDATE-LIST> (compile-template *test-template8*)
#<FUNCTION (LAMBDA (LIST)) {10054100CB}>
NIL
NIL
VALIDATE-LIST> (funcall * *test-list8*)
T
VALIDATE-LIST> 

Compiling the templates offers quite the speed advantage. Here are some tests:


VALIDATE-LIST> (time (dotimes (i 1000000)
                       (validate-list *test-list8* *test-template8*)))
Evaluation took:
  5.684 seconds of real time
  5.704452 seconds of total run time (5.687283 user, 0.017169 system)
  [ Run times consist of 0.168 seconds GC time, and 5.537 seconds non-GC time. ]
  100.35% CPU
  14,732,501,992 processor cycles
  2,415,997,280 bytes consed
  
NIL
VALIDATE-LIST> (let ((fun (compile-template *test-template8*)))
                 (time (dotimes (i 1000000)
                         (funcall fun *test-list8*))))
Evaluation took:
  2.749 seconds of real time
  2.751574 seconds of total run time (2.748586 user, 0.002988 system)
  [ Run times consist of 0.018 seconds GC time, and 2.734 seconds non-GC time. ]
  100.11% CPU
  7,126,663,684 processor cycles
  192,020,368 bytes consed
  
NIL
VALIDATE-LIST> 

Defining your own symbols

If you find you need more functionality you can define your own symbols with the function define-key here is the doctsring:

Takes in a keyword and associates the keyword with the function. The function must accept two arguments, the first an entry ie a value in a list wanting to be validated and the second an object see any of the other uses of DEFINE-KEY in src/validate-list.lisp to get an idea what your λ should > look like. Here is an example


(define-key :n= 
                (lambda (entry arg) 
                  (check-type entry number)
                  (check-type arg number)
                  (= arg entry)))
                  

Now with the new keyword :n= defined this can be used in a template like so where list is '(100) and the template is '((:n= 100)).

Other

The condition unknown-keyword is signalled when you put an unknown keyword in your template. It has two accessors

The condition bad-template-format is signalled when a template is poorly formed. It has three accessors

License

MIT


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 validate-list

Author

K1D77A

License

MIT

Description

Allows you to validate the contents and structure of a list based off of a template

Version

0.0.1

Dependencies
Source

validate-list.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 validate-list.asd

Location

/home/quickref/quicklisp/dists/quicklisp/software/validate-list-20200610-git/validate-list.asd

Systems

validate-list (system)


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

3.1.2 validate-list/package.lisp

Parent

validate-list (system)

Location

package.lisp

Packages

validate-list


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

3.1.3 validate-list/conditions.lisp

Dependency

package.lisp (file)

Parent

validate-list (system)

Location

conditions.lisp

Exported Definitions
Internal Definitions

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

3.1.4 validate-list/validate-list.lisp

Dependency

conditions.lisp (file)

Parent

validate-list (system)

Location

validate-list.lisp

Exported Definitions
Internal Definitions

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

3.1.5 validate-list/compile-template.lisp

Dependency

validate-list.lisp (file)

Parent

validate-list (system)

Location

compile-template.lisp

Exported Definitions

compile-template (function)

Internal Definitions

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

3.1.6 validate-list/tests.lisp

Dependency

compile-template.lisp (file)

Parent

validate-list (system)

Location

tests.lisp

Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 validate-list

Source

package.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Functions

Function: compile-template TEMPLATE &optional SEE-CODE

Takes in a valid TEMPLATE and returns a compiled 1 argument function. This function is called
with a list, ie the one you wish to validate. This function will signal a BAD-TEMPLATE-FORMAT condition if the template is bad.

Package

validate-list

Source

compile-template.lisp (file)

Function: current-keys ()
Package

validate-list

Source

validate-list.lisp (file)

Function: define-key KEY FUNC

Takes in a keyword and associates the keyword with the function. The function must accept two
arguments, the first an entry ie a value in a list wanting to be validated and the second an object
see any of the other uses of DEFINE-KEY in src/validate-list.lisp to get an idea what your lambda should look like. Here is an example (define-key :n=
(lambda (entry arg)
(check-type entry number)
(check-type arg number)
(= entry arg)))
Now with the new keyword :n= defined this can be used in a template like so where list is ’(100)
and the template is ’((:n= 100)).

Package

validate-list

Source

validate-list.lisp (file)

Function: is-valid-template TEMPLATE

Takes in a TEMPLATE and attempts to make sure it has a valid structure. If it does not then signals condition BAD-TEMPLATE-FORMAT

Package

validate-list

Source

validate-list.lisp (file)

Function: repeat-pattern LENGTH PATTERN-LIST

Given a length and a list this will return a list of LENGTH with PATTERN-LIST repeated LENGTH times

Package

validate-list

Source

validate-list.lisp (file)

Function: repeat-test LENGTH VALIDATION-LIST

Returns a list of length LENGTH which simply repeats VALIDATION-LIST

Package

validate-list

Source

validate-list.lisp (file)

Function: same-structures-p LIST TEMPLATE &optional PRINT-LISTS

Given LIST and TEMPLATE of arbitrary depth, return t if they have the same structure or nil if not. In the event of any error this function returns nil, as the assumption is that the structures are not the same.

Package

validate-list

Source

validate-list.lisp (file)

Function: validate-list LIST TEMPLATE

Takes in a LIST that you want to validate, and a TEMPLATE, the TEMPLATE is a list of lists,
each list contains keywords and their values (a full list of keys can be found by calling CURRENT-KEYS), if TEMPLATE is ’invalid’ then the condition BAD-TEMPLATE-FORM is signalled. Each list within the template represents 1 element in the LIST and is a ’description’ of its contents.
For example given the template ’((:equal "key") (:type string :maxlen 40)) this could be used
to validate the list ’("key" "abcdeegadfgfsdf") because as the template says, the first item in
list is "key" and the second according to the template should be of type ’string and no longer
than 40 characters long, which it is not, so this is valid and will return t, if a list fails when
checked against the template then this func signals the condition FAILED-TO-VALIDATE, which
will contain information about where validation failed. For a list of examples see src/tests.lisp, the invalid templates are marked.
In the interests of speed no checks are done to validate the structure of your template
before validation happens,
you can use ’is-valid-template’ as a precursory check to make sure that the template is
constructed with valid plists and valid keywords. There is also the possibility that when you try
to validate a list where you expect a certain structure and get something else you will get a
BAD-TEMPLATE-FORM condition where the template is fine but the list is not, just treat this like
the validation failed.

Package

validate-list

Source

validate-list.lisp (file)


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

5.1.2 Generic functions

Generic Function: bad-template-format-message CONDITION
Generic Function: (setf bad-template-format-message) NEW-VALUE CONDITION
Package

validate-list

Methods
Method: bad-template-format-message (CONDITION bad-template-format)
Method: (setf bad-template-format-message) NEW-VALUE (CONDITION bad-template-format)
Source

conditions.lisp (file)

Generic Function: bad-template-format-signaller CONDITION
Generic Function: (setf bad-template-format-signaller) NEW-VALUE CONDITION
Package

validate-list

Methods
Method: bad-template-format-signaller (CONDITION bad-template-format)
Method: (setf bad-template-format-signaller) NEW-VALUE (CONDITION bad-template-format)
Source

conditions.lisp (file)

Generic Function: bad-template-format-template CONDITION
Generic Function: (setf bad-template-format-template) NEW-VALUE CONDITION
Package

validate-list

Methods
Method: bad-template-format-template (CONDITION bad-template-format)
Method: (setf bad-template-format-template) NEW-VALUE (CONDITION bad-template-format)
Source

conditions.lisp (file)

Generic Function: failed-to-validate-arg CONDITION
Generic Function: (setf failed-to-validate-arg) NEW-VALUE CONDITION
Package

validate-list

Methods
Method: failed-to-validate-arg (CONDITION failed-to-validate)
Method: (setf failed-to-validate-arg) NEW-VALUE (CONDITION failed-to-validate)
Source

conditions.lisp (file)

Generic Function: failed-to-validate-entry CONDITION
Generic Function: (setf failed-to-validate-entry) NEW-VALUE CONDITION
Package

validate-list

Methods
Method: failed-to-validate-entry (CONDITION failed-to-validate)
Method: (setf failed-to-validate-entry) NEW-VALUE (CONDITION failed-to-validate)
Source

conditions.lisp (file)

Generic Function: failed-to-validate-key CONDITION
Generic Function: (setf failed-to-validate-key) NEW-VALUE CONDITION
Package

validate-list

Methods
Method: failed-to-validate-key (CONDITION failed-to-validate)
Method: (setf failed-to-validate-key) NEW-VALUE (CONDITION failed-to-validate)
Source

conditions.lisp (file)

Generic Function: failed-to-validate-message CONDITION
Generic Function: (setf failed-to-validate-message) NEW-VALUE CONDITION
Package

validate-list

Methods
Method: failed-to-validate-message (CONDITION failed-to-validate)
Method: (setf failed-to-validate-message) NEW-VALUE (CONDITION failed-to-validate)
Source

conditions.lisp (file)

Generic Function: unknown-keyword-keyword CONDITION
Generic Function: (setf unknown-keyword-keyword) NEW-VALUE CONDITION
Package

validate-list

Methods
Method: unknown-keyword-keyword (CONDITION unknown-keyword)
Method: (setf unknown-keyword-keyword) NEW-VALUE (CONDITION unknown-keyword)
Source

conditions.lisp (file)

Generic Function: unknown-keyword-message CONDITION
Generic Function: (setf unknown-keyword-message) NEW-VALUE CONDITION
Package

validate-list

Methods
Method: unknown-keyword-message (CONDITION unknown-keyword)
Method: (setf unknown-keyword-message) NEW-VALUE (CONDITION unknown-keyword)
Source

conditions.lisp (file)


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

5.1.3 Conditions

Condition: bad-template-format ()
Package

validate-list

Source

conditions.lisp (file)

Direct superclasses

error (condition)

Direct methods
Direct slots
Slot: template
Initargs

:bad-template-format-template

Readers

bad-template-format-template (generic function)

Writers

(setf bad-template-format-template) (generic function)

Slot: signaller

Contains the condition which was called that caused this condition to be signalled

Initargs

:bad-template-format-signaller

Readers

bad-template-format-signaller (generic function)

Writers

(setf bad-template-format-signaller) (generic function)

Slot: message

Message indicating what when wrong

Initargs

:bad-template-format-message

Readers

bad-template-format-message (generic function)

Writers

(setf bad-template-format-message) (generic function)

Condition: failed-to-validate ()
Package

validate-list

Source

conditions.lisp (file)

Direct superclasses

error (condition)

Direct methods
Direct slots
Slot: failed-to-validate-key
Initargs

:failed-to-validate-key

Readers

failed-to-validate-key (generic function)

Writers

(setf failed-to-validate-key) (generic function)

Slot: failed-to-validate-arg
Initargs

:failed-to-validate-arg

Readers

failed-to-validate-arg (generic function)

Writers

(setf failed-to-validate-arg) (generic function)

Slot: failed-to-validate-entry
Initargs

:failed-to-validate-entry

Readers

failed-to-validate-entry (generic function)

Writers

(setf failed-to-validate-entry) (generic function)

Slot: failed-to-validate-message

Message indicating what when wrong

Initargs

:failed-to-validate-message

Readers

failed-to-validate-message (generic function)

Writers

(setf failed-to-validate-message) (generic function)

Condition: unknown-keyword ()
Package

validate-list

Source

conditions.lisp (file)

Direct superclasses

error (condition)

Direct methods
Direct slots
Slot: keyword
Initargs

:unknown-keyword-keyword

Readers

unknown-keyword-keyword (generic function)

Writers

(setf unknown-keyword-keyword) (generic function)

Slot: message

Message indicating what when wrong

Initargs

:unknown-keyword-message

Readers

unknown-keyword-message (generic function)

Writers

(setf unknown-keyword-message) (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: *broken-struct-list1*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *broken-struct1*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *functions*
Package

validate-list

Source

validate-list.lisp (file)

Special Variable: *test-list1*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list10*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list11*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list12*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list12a*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list13*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list14*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list15*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list16*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list17*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list18*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list19*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list2*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list3*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list4*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list5*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list6*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list7*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list8*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-list9*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template1*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template10*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template11*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template12*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template12a*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template13*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template14*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template15*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template16*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template17*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template18*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template19*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template2*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template3*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template4*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template5*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template6*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template7*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template8*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *test-template9*
Package

validate-list

Source

tests.lisp (file)

Special Variable: *validate-list-p-err-message*
Package

validate-list

Source

validate-list.lisp (file)


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

5.2.2 Functions

Function: argument TEMPLATE-FUN
Package

validate-list

Source

compile-template.lisp (file)

Function: call-fun-check-true FUN ARG1 ARG2
Package

validate-list

Source

compile-template.lisp (file)

Function: compile-template-and-test LIST TEMPLATE
Package

validate-list

Source

tests.lisp (file)

Function: compile-template-entry TEMPLATE-ENTRY
Package

validate-list

Source

compile-template.lisp (file)

Function: fun TEMPLATE-FUN
Package

validate-list

Source

compile-template.lisp (file)

Function: handle-between ENTRY BETWEEN-LIST
Package

validate-list

Source

validate-list.lisp (file)

Function: handle-contents ENTRY TEMPLATE-ENTRY
Package

validate-list

Source

validate-list.lisp (file)

Function: handle-equal ENTRY EQUAL
Package

validate-list

Source

validate-list.lisp (file)

Function: handle-greater-than ENTRY GREATER-THAN
Package

validate-list

Source

validate-list.lisp (file)

Function: handle-length ENTRY LENGTH
Package

validate-list

Source

validate-list.lisp (file)

Function: handle-less-than ENTRY LESS-THAN
Package

validate-list

Source

validate-list.lisp (file)

Function: handle-maxlen ENTRY MAXLEN
Package

validate-list

Source

validate-list.lisp (file)

Function: handle-minlen ENTRY MINLEN
Package

validate-list

Source

validate-list.lisp (file)

Function: handle-or ENTRY LIST-OF-POTENTIALS
Package

validate-list

Source

validate-list.lisp (file)

Function: handle-satisfies ENTRY FUNC
Package

validate-list

Source

validate-list.lisp (file)

Function: handle-type ENTRY TYPE
Package

validate-list

Source

validate-list.lisp (file)

Function: keyword->function KEYWORD

Given a keyword in KEYWORD, this function looks for the associated function in *functions* if found then the function is returned, otherwise a UNKNOWN-KEYWORD condition is signalled.

Package

validate-list

Source

validate-list.lisp (file)

Function: map-plist FUNC PLIST

Maps a PLIST and calls FUNC that accepts two arguments. returns a list of funcall-result

Package

validate-list

Source

validate-list.lisp (file)

Function: process-template-entry TEMPLATE-ENTRY ENTRY
Package

validate-list

Source

validate-list.lisp (file)

Function: process-template-funs TEMPLATE

Takes in a TEMPLATE and converts all the key args within each plist into the associated functions ready to be called

Package

validate-list

Source

compile-template.lisp (file)

Function: signal-bad-template-format TEMPLATE MESSAGE &optional SIGNALLER
Package

validate-list

Source

conditions.lisp (file)

Function: signal-failed-to-validate KEYWORD ARG ENTRY MESSAGE
Package

validate-list

Source

conditions.lisp (file)

Function: signal-unknown-keyword KEYWORD MESSAGE
Package

validate-list

Source

conditions.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   V  
Index Entry  Section

F
File, Lisp, validate-list.asd: The validate-list․asd file
File, Lisp, validate-list/compile-template.lisp: The validate-list/compile-template․lisp file
File, Lisp, validate-list/conditions.lisp: The validate-list/conditions․lisp file
File, Lisp, validate-list/package.lisp: The validate-list/package․lisp file
File, Lisp, validate-list/tests.lisp: The validate-list/tests․lisp file
File, Lisp, validate-list/validate-list.lisp: The validate-list/validate-list․lisp file

L
Lisp File, validate-list.asd: The validate-list․asd file
Lisp File, validate-list/compile-template.lisp: The validate-list/compile-template․lisp file
Lisp File, validate-list/conditions.lisp: The validate-list/conditions․lisp file
Lisp File, validate-list/package.lisp: The validate-list/package․lisp file
Lisp File, validate-list/tests.lisp: The validate-list/tests․lisp file
Lisp File, validate-list/validate-list.lisp: The validate-list/validate-list․lisp file

V
validate-list.asd: The validate-list․asd file
validate-list/compile-template.lisp: The validate-list/compile-template․lisp file
validate-list/conditions.lisp: The validate-list/conditions․lisp file
validate-list/package.lisp: The validate-list/package․lisp file
validate-list/tests.lisp: The validate-list/tests․lisp file
validate-list/validate-list.lisp: The validate-list/validate-list․lisp file

Jump to:   F   L   V  

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

A.2 Functions

Jump to:   (  
A   B   C   D   F   G   H   I   K   M   P   R   S   U   V  
Index Entry  Section

(
(setf bad-template-format-message): Exported generic functions
(setf bad-template-format-message): Exported generic functions
(setf bad-template-format-signaller): Exported generic functions
(setf bad-template-format-signaller): Exported generic functions
(setf bad-template-format-template): Exported generic functions
(setf bad-template-format-template): Exported generic functions
(setf failed-to-validate-arg): Exported generic functions
(setf failed-to-validate-arg): Exported generic functions
(setf failed-to-validate-entry): Exported generic functions
(setf failed-to-validate-entry): Exported generic functions
(setf failed-to-validate-key): Exported generic functions
(setf failed-to-validate-key): Exported generic functions
(setf failed-to-validate-message): Exported generic functions
(setf failed-to-validate-message): Exported generic functions
(setf unknown-keyword-keyword): Exported generic functions
(setf unknown-keyword-keyword): Exported generic functions
(setf unknown-keyword-message): Exported generic functions
(setf unknown-keyword-message): Exported generic functions

A
argument: Internal functions

B
bad-template-format-message: Exported generic functions
bad-template-format-message: Exported generic functions
bad-template-format-signaller: Exported generic functions
bad-template-format-signaller: Exported generic functions
bad-template-format-template: Exported generic functions
bad-template-format-template: Exported generic functions

C
call-fun-check-true: Internal functions
compile-template: Exported functions
compile-template-and-test: Internal functions
compile-template-entry: Internal functions
current-keys: Exported functions

D
define-key: Exported functions

F
failed-to-validate-arg: Exported generic functions
failed-to-validate-arg: Exported generic functions
failed-to-validate-entry: Exported generic functions
failed-to-validate-entry: Exported generic functions
failed-to-validate-key: Exported generic functions
failed-to-validate-key: Exported generic functions
failed-to-validate-message: Exported generic functions
failed-to-validate-message: Exported generic functions
fun: Internal functions
Function, argument: Internal functions
Function, call-fun-check-true: Internal functions
Function, compile-template: Exported functions
Function, compile-template-and-test: Internal functions
Function, compile-template-entry: Internal functions
Function, current-keys: Exported functions
Function, define-key: Exported functions
Function, fun: Internal functions
Function, handle-between: Internal functions
Function, handle-contents: Internal functions
Function, handle-equal: Internal functions
Function, handle-greater-than: Internal functions
Function, handle-length: Internal functions
Function, handle-less-than: Internal functions
Function, handle-maxlen: Internal functions
Function, handle-minlen: Internal functions
Function, handle-or: Internal functions
Function, handle-satisfies: Internal functions
Function, handle-type: Internal functions
Function, is-valid-template: Exported functions
Function, keyword->function: Internal functions
Function, map-plist: Internal functions
Function, process-template-entry: Internal functions
Function, process-template-funs: Internal functions
Function, repeat-pattern: Exported functions
Function, repeat-test: Exported functions
Function, same-structures-p: Exported functions
Function, signal-bad-template-format: Internal functions
Function, signal-failed-to-validate: Internal functions
Function, signal-unknown-keyword: Internal functions
Function, validate-list: Exported functions

G
Generic Function, (setf bad-template-format-message): Exported generic functions
Generic Function, (setf bad-template-format-signaller): Exported generic functions
Generic Function, (setf bad-template-format-template): Exported generic functions
Generic Function, (setf failed-to-validate-arg): Exported generic functions
Generic Function, (setf failed-to-validate-entry): Exported generic functions
Generic Function, (setf failed-to-validate-key): Exported generic functions
Generic Function, (setf failed-to-validate-message): Exported generic functions
Generic Function, (setf unknown-keyword-keyword): Exported generic functions
Generic Function, (setf unknown-keyword-message): Exported generic functions
Generic Function, bad-template-format-message: Exported generic functions
Generic Function, bad-template-format-signaller: Exported generic functions
Generic Function, bad-template-format-template: Exported generic functions
Generic Function, failed-to-validate-arg: Exported generic functions
Generic Function, failed-to-validate-entry: Exported generic functions
Generic Function, failed-to-validate-key: Exported generic functions
Generic Function, failed-to-validate-message: Exported generic functions
Generic Function, unknown-keyword-keyword: Exported generic functions
Generic Function, unknown-keyword-message: Exported generic functions

H
handle-between: Internal functions
handle-contents: Internal functions
handle-equal: Internal functions
handle-greater-than: Internal functions
handle-length: Internal functions
handle-less-than: Internal functions
handle-maxlen: Internal functions
handle-minlen: Internal functions
handle-or: Internal functions
handle-satisfies: Internal functions
handle-type: Internal functions

I
is-valid-template: Exported functions

K
keyword->function: Internal functions

M
map-plist: Internal functions
Method, (setf bad-template-format-message): Exported generic functions
Method, (setf bad-template-format-signaller): Exported generic functions
Method, (setf bad-template-format-template): Exported generic functions
Method, (setf failed-to-validate-arg): Exported generic functions
Method, (setf failed-to-validate-entry): Exported generic functions
Method, (setf failed-to-validate-key): Exported generic functions
Method, (setf failed-to-validate-message): Exported generic functions
Method, (setf unknown-keyword-keyword): Exported generic functions
Method, (setf unknown-keyword-message): Exported generic functions
Method, bad-template-format-message: Exported generic functions
Method, bad-template-format-signaller: Exported generic functions
Method, bad-template-format-template: Exported generic functions
Method, failed-to-validate-arg: Exported generic functions
Method, failed-to-validate-entry: Exported generic functions
Method, failed-to-validate-key: Exported generic functions
Method, failed-to-validate-message: Exported generic functions
Method, unknown-keyword-keyword: Exported generic functions
Method, unknown-keyword-message: Exported generic functions

P
process-template-entry: Internal functions
process-template-funs: Internal functions

R
repeat-pattern: Exported functions
repeat-test: Exported functions

S
same-structures-p: Exported functions
signal-bad-template-format: Internal functions
signal-failed-to-validate: Internal functions
signal-unknown-keyword: Internal functions

U
unknown-keyword-keyword: Exported generic functions
unknown-keyword-keyword: Exported generic functions
unknown-keyword-message: Exported generic functions
unknown-keyword-message: Exported generic functions

V
validate-list: Exported functions

Jump to:   (  
A   B   C   D   F   G   H   I   K   M   P   R   S   U   V  

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

A.3 Variables

Jump to:   *  
F   K   M   S   T  
Index Entry  Section

*
*broken-struct-list1*: Internal special variables
*broken-struct1*: Internal special variables
*functions*: Internal special variables
*test-list1*: Internal special variables
*test-list10*: Internal special variables
*test-list11*: Internal special variables
*test-list12*: Internal special variables
*test-list12a*: Internal special variables
*test-list13*: Internal special variables
*test-list14*: Internal special variables
*test-list15*: Internal special variables
*test-list16*: Internal special variables
*test-list17*: Internal special variables
*test-list18*: Internal special variables
*test-list19*: Internal special variables
*test-list2*: Internal special variables
*test-list3*: Internal special variables
*test-list4*: Internal special variables
*test-list5*: Internal special variables
*test-list6*: Internal special variables
*test-list7*: Internal special variables
*test-list8*: Internal special variables
*test-list9*: Internal special variables
*test-template1*: Internal special variables
*test-template10*: Internal special variables
*test-template11*: Internal special variables
*test-template12*: Internal special variables
*test-template12a*: Internal special variables
*test-template13*: Internal special variables
*test-template14*: Internal special variables
*test-template15*: Internal special variables
*test-template16*: Internal special variables
*test-template17*: Internal special variables
*test-template18*: Internal special variables
*test-template19*: Internal special variables
*test-template2*: Internal special variables
*test-template3*: Internal special variables
*test-template4*: Internal special variables
*test-template5*: Internal special variables
*test-template6*: Internal special variables
*test-template7*: Internal special variables
*test-template8*: Internal special variables
*test-template9*: Internal special variables
*validate-list-p-err-message*: Internal special variables

F
failed-to-validate-arg: Exported conditions
failed-to-validate-entry: Exported conditions
failed-to-validate-key: Exported conditions
failed-to-validate-message: Exported conditions

K
keyword: Exported conditions

M
message: Exported conditions
message: Exported conditions

S
signaller: Exported conditions
Slot, failed-to-validate-arg: Exported conditions
Slot, failed-to-validate-entry: Exported conditions
Slot, failed-to-validate-key: Exported conditions
Slot, failed-to-validate-message: Exported conditions
Slot, keyword: Exported conditions
Slot, message: Exported conditions
Slot, message: Exported conditions
Slot, signaller: Exported conditions
Slot, template: Exported conditions
Special Variable, *broken-struct-list1*: Internal special variables
Special Variable, *broken-struct1*: Internal special variables
Special Variable, *functions*: Internal special variables
Special Variable, *test-list1*: Internal special variables
Special Variable, *test-list10*: Internal special variables
Special Variable, *test-list11*: Internal special variables
Special Variable, *test-list12*: Internal special variables
Special Variable, *test-list12a*: Internal special variables
Special Variable, *test-list13*: Internal special variables
Special Variable, *test-list14*: Internal special variables
Special Variable, *test-list15*: Internal special variables
Special Variable, *test-list16*: Internal special variables
Special Variable, *test-list17*: Internal special variables
Special Variable, *test-list18*: Internal special variables
Special Variable, *test-list19*: Internal special variables
Special Variable, *test-list2*: Internal special variables
Special Variable, *test-list3*: Internal special variables
Special Variable, *test-list4*: Internal special variables
Special Variable, *test-list5*: Internal special variables
Special Variable, *test-list6*: Internal special variables
Special Variable, *test-list7*: Internal special variables
Special Variable, *test-list8*: Internal special variables
Special Variable, *test-list9*: Internal special variables
Special Variable, *test-template1*: Internal special variables
Special Variable, *test-template10*: Internal special variables
Special Variable, *test-template11*: Internal special variables
Special Variable, *test-template12*: Internal special variables
Special Variable, *test-template12a*: Internal special variables
Special Variable, *test-template13*: Internal special variables
Special Variable, *test-template14*: Internal special variables
Special Variable, *test-template15*: Internal special variables
Special Variable, *test-template16*: Internal special variables
Special Variable, *test-template17*: Internal special variables
Special Variable, *test-template18*: Internal special variables
Special Variable, *test-template19*: Internal special variables
Special Variable, *test-template2*: Internal special variables
Special Variable, *test-template3*: Internal special variables
Special Variable, *test-template4*: Internal special variables
Special Variable, *test-template5*: Internal special variables
Special Variable, *test-template6*: Internal special variables
Special Variable, *test-template7*: Internal special variables
Special Variable, *test-template8*: Internal special variables
Special Variable, *test-template9*: Internal special variables
Special Variable, *validate-list-p-err-message*: Internal special variables

T
template: Exported conditions

Jump to:   *  
F   K   M   S   T  

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

A.4 Data types

Jump to:   B   C   F   P   S   U   V  
Index Entry  Section

B
bad-template-format: Exported conditions

C
Condition, bad-template-format: Exported conditions
Condition, failed-to-validate: Exported conditions
Condition, unknown-keyword: Exported conditions

F
failed-to-validate: Exported conditions

P
Package, validate-list: The validate-list package

S
System, validate-list: The validate-list system

U
unknown-keyword: Exported conditions

V
validate-list: The validate-list system
validate-list: The validate-list package

Jump to:   B   C   F   P   S   U   V