The unicly Reference Manual

Table of Contents

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

The unicly Reference Manual

This is the unicly Reference Manual, version 2011.8.31, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 12:43:49 2018 GMT+0.


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

1 Introduction

;;; :FILE-CREATED 
;;; :FILE unicly/README
;;; ==============================

DESCRIPTION:

Unicly is a Common Lisp library for generation of UUIDs (Universally Unique
Identifiers) as described by RFC 4122.


As of 2011-09-13 Unicly is known to compile on: 
   SBCL 1.47+  (on Linux x86oids) [1]
   CLisp 2.49  (on Linux x86 32)
   LispWorks 6 (Personal on Linux 86 32) [2]

Please do let us know if you can confirm whether Unicly is known to build on
your platform and implementation.

[1] SBCL should build on MacOS providing that sb-impl::*default-external-format*
    is set to :UTF-8 and :SB-UNICODE is present as a member cl:*features*

[2] See notes below regarding LispWorks optimization opportunities

INSTALLATION:

SHELL> cd /parent/dir/where/you/put/cl-repos/

SHELL> git clone git://github.com/mon-key/unicly.git 

SHELL> cd unicly

Unicly is loadable with Quicklisp assuming a directory containing unicly.asd is
present as an element of ASDF:*CENTRAL-REGISTRY*.

CL-USER> (push #P"/parent/dir/where/you/put/cl-repos/unicly/" asdf:*central-registry*)

CL-USER> (quicklisp:quickload 'unicly)

Or for the perverse who'd like to see what their lisp can't optimize away:

CL-USER> (quicklisp:quickload 'unicly :verbose t :explain t)

INSTALLATION-ISSUES:

- SBCL

In the past there have been some reports that Unicly will not compile on SBCLs
running under a MacOS due to the presence of the characters "▶▶▶" in Unicly
docstrings, e.g.:

CL-USER> (code-char #x25b6)
;=> #\BLACK_RIGHT-POINTING_TRIANGLE 

We believe this is not MacOS specific but rather a side-effect of the buildtime
environmental variables LOCALE and LC_CTYPE and their influence on value of
sb-impl::*default-external-format* such that when its value was other than
:UTF-8 the docstrings would not compile.

A Fix for the problem was to ensure that the variable
`sb-impl::*default-external-format*' evaluated to :UTF-8 and if not to set it to
do so with:

 (setf sb-impl::*default-external-format* :UTF-8)

However this may or may not be an acceptable solution for your application.
As such, as of 2011-09-12 the offending string of "▶▶▶" characters have been
removed from all Unicly docstrings and we believe that this will no longer pose
a problem.  This said, should you experience compiler decoding errors with
Unicly please do let us know.

Note, when building Unicly on SBCL we assume that your system is Unicode capable
and that :SB-UNICODE is present in *features* e.g.:

CL-USER> (and (car (member :SB-UNICODE *features*)) t)
;=> T

- LISPWORKS

Although Unicly system builds on Lispworks there are known deficiencies around
Unicly's declarations of objects of type CL:CHARACTER and CL:STRING. Unicly is
strongly typed and excessively inlined and some declarations do not make full
use of internal LispWorks character handling around objets of type
lw:simple-character, lw:text-string, etc.  We have made some effort to bridge
the differences but work is ongoing and there are likely myriad opportunities to
make Unicly faster on Lispworks. This said, the work required to get an optimized
Unicly up to speed on LispWorks is not insurmountable but will require input
from capable LispWorks user(s). Some notes are available in unicly/LISPWORKS
Likely further inspection of the manual is required:
 (URL `http://www.lispworks.com/documentation/lw60/LW/html/lw.htm')
Needless to say, Patches are welcome.

USAGE:

(in-package #:unicly)
;=> #

As per RFC 4122 "Appendix C - Some Name Space IDs" the Unicly package exports
four "namespaces", these are:

UNICLY> *uuid-namespace-dns*
;=> 6ba7b810-9dad-11d1-80b4-00c04fd430c8

UNICLY> *uuid-namespace-url* 
;=> 6ba7b811-9dad-11d1-80b4-00c04fd430c8

UNICLY> *uuid-namespace-oid*
;=> 6ba7b812-9dad-11d1-80b4-00c04fd430c8

UNICLY> *uuid-namespace-x500*
;=> 6ba7b814-9dad-11d1-80b4-00c04fd430c8

The above "namespaces" are "canonical" in so much as they are presented by the RFC.

Indeed, a common misconception is that the above four namespaces are the _only_
namespaces one can/should use when working with v3 and v5 uuids.

However, one is free to define any number of other "namespaces" to contain UUID
objects and one is free to utilize these namespaces as need dictates.

A problem that arises though is how does one create a UUID "namespace"?
This is a sort of bootstrapping issue.

The RFC 4122 describes a mechanism for creating two types of UUIDs which may
serve as initial "namespaces" from which one can then generate other types of
UUIDs with reasonable certainty that the UUIDs so generated will remain unique.

The first of these is a v1 or time based UUID. Unicly does not currently provide
an interface for creation of v1 UUIDs.

The second of these is a v4 or random UUID. This is Unicly's preferred interface
for creation of an initial namespace. 

Once one has a handle on an initial UUID namespace that namespace may then be
leveraged to create any number of new UUID namespaces using MAKE-V3-UUID OR
MAKE-V5-UUID. This is a commonly overlooked/misunderstood aspect of RFC 4122!

So, to be clear, the real utility of UUIDs isn't by way of the more pedestrian
v1 and v4 UUIDs, but rather by utilization of v3 and v5 UUIDs in a manner
similar to that of RDF whereby a namespace is treated as a URI and a name in that
namespace is treated as a URIref. 

We can't overstate this point enough - don't retstrict use of UUIDs to only the
v1 or v4 forms. Doing so is (by analogy with RDF) equivalent to providing a URI
for every object gererated by a system and then never bothering to reference any
qualified names within that namespace! Or (by analogy with Common Lisp) this is
not unlike defining a package object which doesn't use any symbols just to get
at its identity, e.g.:

 (let ((hex (make-array 16
                        :element-type 'base-char
                        :initial-contents (list #\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9
                                                #\A #\B #\C #\D #\E #\F)))
       (pkg-name '()))
   (loop 
      repeat 32
      for rand = (random 16)
      for rand-char = (aref hex rand)
      collect rand-char into rand-bag
      finally (setf pkg-name (coerce  rand-bag 'string)))
   (setf pkg-name
         (package-name  (eval `(defpackage ,pkg-name)))))


In any event, the easiest way to create a new "namespace" is with MAKE-V4-UUID.
Note, because the v4 uuid is the "random" UUID when evaluating the following
form your return value will obv. be somewhat different :)

UNICLY> (make-v4-uuid)
;=> 2f20bdfa-cd67-4150-8500-80c94821bbda

Evaluating the above form returns the printed representation of UUID object.

To cache a namespace we need to bind it to a special variable.
Below we use a defparameter form to do this but longer running applications
would probably use CL:DEFVAR or CL:DEFCONSTANT.

The easiest way to persist a UUID object is to bind its printed string
representation. To get the string representation of a UUID we use
UUID-PRINC-TO-STRING.  Note, per RFC 4122 case is significant when the string
representation of a UUID is output, IOW, sticklers should be careful when using
CL printing function which depend on dynamic value of *PRINT-CASE*!

UNICLY> (defparameter *unique-random-namespace* 
	   (uuid-princ-to-string  (unicly:make-v4-uuid))) 
;=> *UNIQUE-RANDOM-NAMESPACE*

UNICLY> *UNIQUE-RANDOM-NAMESPACE*
;=> "77b84745-ab13-49c6-8fdc-9afaabc51c52"

To convert this string back to a UUID use MAKE-UUID-FROM-STRING:

UNICLY> (setf *unique-random-namespace* 
	      (make-uuid-from-string *unique-random-namespace*))
;=> 77b84745-ab13-49c6-8fdc-9afaabc51c52

UNICLY> *unique-random-namespace*
;=> 77b84745-ab13-49c6-8fdc-9afaabc51c52

To print a UUID with a URN quailifier use UUID-AS-URN-STRING:

UNICLY> (uuid-as-urn-string nil *unique-random-namespace*)
;=> "urn:uuid:77b84745-ab13-49c6-8fdc-9afaabc51c52"

v4 UUIDs are fine so long as you don't need to persist an objects
identity and simply need a throw away or single session UUID.
Indeed, one could serialize/deserialize v4 UUIDs from a string to object
representation with each session if desired.

However, as indicated above a v4 UUID is best used as a "seed-value" for
generating a namespace which is unique to your application.

For persistent UUID solutions it is recommended to use MAKE-V5-UUID by
providing a persisted UUID namespace for an object to reside in.

You can make your own fabulous namespace like this:

UNICLY> (defparameter *my-fabulous-namespace* 
	 (make-v5-uuid *unique-random-namespace* "com.bubba.namespace"))
;=> *MY-FABULOUS-NAMESPACE*

UNICLY> *MY-FABULOUS-NAMESPACE*
;=> e5c2a048-863f-5c7d-a894-607070d2d299

Create some objects in the namespace *my-fabulous-namespace*:

UNICLY> (make-v5-uuid *my-fabulous-namespace* (namestring (user-homedir-pathname)))
;=> c0f2a167-dae7-55c0-ad57-1d8bad0444d3

UNICLY> (make-v5-uuid *my-fabulous-namespace* (namestring *default-pathname-defaults*))
;=> a5ace91c-d657-5f5c-abef-81bbef52d27c

UNICLY> (setf *default-pathname-defaults* (user-homedir-pathname))
;=> #P"/home/you/"

You should now find that the UUID for the CL:NAMESTRING of *DEFAULT-PATHNAME-DEFAULTS*
is the same as that of the namestring of USER-HOMEDIR-PATHNAME:

UNICLY> (make-v5-uuid *my-fabulous-namespace* (namestring *default-pathname-defaults*))
;=> c0f2a167-dae7-55c0-ad57-1d8bad0444d3

Note that each object returned by MAKE-V5-UUID has unique identity under CL:EQUALP:

UNICLY> (equalp (make-v5-uuid *my-fabulous-namespace* (namestring (user-homedir-pathname)))
                (make-v5-uuid *my-fabulous-namespace* (namestring *default-pathname-defaults*)))
;=> NIL

To tests equality among two UUIDs (even where their CL:PRINT-OBJECT is
identical) one must first convert the UUID to an intermediary format and compare
the identity of the intermediate formats instead.

One way to do this is test CL:EQUAL for two UUIDs using their string representation:

UNICLY> (equal (uuid-princ-to-string 
		 (make-v5-uuid *my-fabulous-namespace* (namestring (user-homedir-pathname))))
		(uuid-princ-to-string 
		 (make-v5-uuid *my-fabulous-namespace* (namestring *default-pathname-defaults*))))
;=> T

CL:EQUAL finds the two UUIDs above as having identical string representations.
However, checking string values for object identity is ugly b/c internally UUID
objects are represented as unsigned integer values.

Unicly provides features for comparing UUID representations in various
intermediary formats other than as strings and further below we present some
examples of Unicly's representations of UUIDs in forms other than strings and
illustrate some cleaner ways to interrogate UUID equality.

So, now that you've got a handle on a fabulous UUID namespace how do you persist it?
The quick and dirty way is to write the UUID string representation of
*my-fabulous-namespace* to a file somewhere.

UNICLY> (with-open-file (persist (make-pathname :directory '(:absolute "tmp") 
                                                :name "persisted-fabulous-namespace"
                                                :type "uuid")
                                 :direction :output
                                 :if-exists :supersede
                                 :if-does-not-exist :create)
          ;; Here we CL:PRIN1 the UUID string representation.
	  ;; This is for illustrative purposes, there are other ways.
          (prin1 *MY-FABULOUS-NAMESPACE*  persist))
;=> "e5c2a048-863f-5c7d-a894-607070d2d299"

UNICLY> (setf *my-fabulous-namespace* nil)
;=> NIL

To restore the string representation of the persisted UUID into the
*my-fabulous-namespace* variable just read in the contents of the file:

UNICLY> (with-open-file (persist (make-pathname :directory
                                                '(:absolute "tmp")
                                                :name "persisted-fabulous-namespace"
                                                :type "uuid")
                                 :direction :input
                                 :if-does-not-exist :error)
          (setf *my-fabulous-namespace* 
                (make-uuid-from-string (read-line  persist))))
;=> e5c2a048-863f-5c7d-a894-607070d2d299

When serialzing/deserializing large numbers of UUIDs it may be more expedient to
use other intermediary representations of your UUIDs. Unicly provides interfaces
for reading, writing, and converting UUIDs across various representations
including bit-vectors, byte-arrays, 128-bit integers, strings, etc.

Following examples illustrate some more of the Unicly interface.

We use the value of the v4-uuid in the variable *unique-random-namespace*
defined earlier above, but feel free to substitute *my-fabulous-namespace* (or
equivalent).

Testing the equivalence of two UUID objects:

UNICLY> (uuid-eql 
         (make-v5-uuid *unique-random-namespace* "bubba")
         (make-v5-uuid *unique-random-namespace* "bubba"))
;=> T

Printing a UUID object in hex-string-36 format:

UNICLY> (uuid-princ-to-string (make-v5-uuid *unique-random-namespace* "bubba"))
;=> "065944a4-7566-53b2-811b-11a20e0bfed2"

Testing equivalence of two UUID objects where the first is generated using
MAKE-V5-UUID and the second is generated from an equivelent hex-string-36
representation:

UNICLY> (uuid-eql 
         (make-v5-uuid *unique-random-namespace* "bubba")
         (make-uuid-from-string "065944a4-7566-53b2-811b-11a20e0bfed2"))
;=> T

Binding a variable *another-unique-random-namespace* for use as a namespace.
We initally bind it to the hex-string-36 representation of a v4 UUID:

UNICLY> (defparameter *another-unique-random-namespace* 
          (uuid-princ-to-string (unicly:make-v4-uuid)))
;=> *ANOTHER-UNIQUE-RANDOM-NAMESPACE*

Binding the *another-unique-random-namespace* variable to a UUID object:
UNICLY> (setf *another-unique-random-namespace*
              (make-uuid-from-string *another-unique-random-namespace*))
;=> f65c8371-0c41-4913-96e6-8a917666aa51

Creating a container to hold 32 v5 UUIDs for 16 names each of which will occupy
two distinct namespaces:

UNICLY> (defparameter *v5-uuids-in-distinct-unique-random-namespaces* '()) 
;=> *V5-UUIDS-IN-DISTINCT-UNIQUE-RANDOM-NAMESPACES*

Adding 32 v5 UUIDS to the container where each is a cons with the head of each
cons a UUID object and the tail the name of some object in a namespace.
For each name we create two UUIDs one will occupy the namespace
*unique-random-namespace* the other will occupy the namepsace
*another-unique-random-namespace*:

UNICLY> (loop
           initially (setf *v5-uuids-in-distinct-unique-random-namespaces* nil)
           for bubba in (loop
                           for cnt from 0 below 16  
                           collect (format nil "bubba-~D" cnt))
           do (push (cons (make-v5-uuid *unique-random-namespace*  bubba) bubba)
                    *v5-uuids-in-distinct-unique-random-namespaces*)
           (push (cons (make-v5-uuid *another-unique-random-namespace* bubba) bubba)
                 *v5-uuids-in-distinct-unique-random-namespaces*)
           finally (return *v5-uuids-in-distinct-unique-random-namespaces* ))

;=> ((7c34b05e-d7a0-573e-baa2-7cc407532609 . "bubba-15")
;     (f7922a16-0b67-5329-87c9-71fdaa52c6c1 . "bubba-15")
;     { ... }
;     (7af9b747-e1f4-59b1-8f05-0acb70220817 . "bubba-0")
;     (f3228291-0a24-5a46-a9e2-7963d4671069 . "bubba-0"))

Retrieving the UUID for the name "bubba-8" in the namespace
*unique-random-namespace*:

UNICLY> (assoc 
         (make-v5-uuid *unique-random-namespace* "bubba-8")
         *v5-uuids-in-distinct-unique-random-namespaces*
         :test #'uuid-eql)
;=> (8e64c855-70fd-5d53-82ce-67e545f724a1 . "bubba-8")

Retrieving the UUID for the name "bubba-8" in the namespace
*another-unique-random-namespace*:

UNICLY> (assoc 
         (make-v5-uuid *another-unique-random-namespace* "bubba-8")
         *v5-uuids-in-distinct-unique-random-namespaces*
         :test #'uuid-eql)
;=> (ef74e326-4ecc-5edc-9b55-e69e6069610a . "bubba-8")

Testing if two identical names can be UUID-EQL when each occupies a different
namespace:
UNICLY> (uuid-eql 
         (make-v5-uuid *unique-random-namespace* "bubba-8")
         (make-v5-uuid *another-unique-random-namespace* "bubba-8"))
;=> NIL

Testing if two identical names can be UUID-EQL when each occupies the same
namespace:

UNICLY> (uuid-eql 
         (make-v5-uuid *unique-random-namespace* "bubba-8")
         (car (assoc 
               (make-v5-uuid *unique-random-namespace* "bubba-8")
               *v5-uuids-in-distinct-unique-random-namespaces*
               :test #'uuid-eql)))
;=> T

Examining the bit-vector representation of the *unique-random-namespace* UUID:

UNICLY> (uuid-to-bit-vector *unique-random-namespace*)
;=> #*01110111101110000100011101000101101010110001001101001001110001101000111111011100100110101111101010101011110001010001110001010010

Testing with UNIQUE-UNIVERSAL-IDENTIFIER-P whether the value of
*unique-random-namespace* is an instance of class UNIQUE-UNIVERSAL-IDENTIFIER:

UNICLY> (unique-universal-identifier-p *unique-random-namespace*)
;=> T

When testing an object with UNIQUE-UNIVERSAL-IDENTIFIER-P if the object is a
bit-vector and the form of that bit-vector satisfies UUID-BIT-VECTOR-128-P and
the appropriate version bit of the bit-vector is set, indication is given that
the bit-vector may be coerceable to an object which would satisfy
UNIQUE-UNIVERSAL-IDENTIFIER-P. This indication is provided as the CL:NTH-VALUE 1
as illustrated by the following return value:

UNICLY> (unique-universal-identifier-p (uuid-to-bit-vector *unique-random-namespace*))
;=> NIL, (UUID-BIT-VECTOR-128 4)

Testing whether the null-uuid satisfies UNIQUE-UNIVERSAL-IDENTIFIER-P:

UNICLY> (unique-universal-identifier-p (make-null-uuid))
;=> T

Converting a UUID to bit-vector representation with UUID-TO-BIT-VECTOR then
converting that to an integer value with UUID-BIT-VECTOR-TO-INTEGER:

UNICLY> (uuid-bit-vector-to-integer (uuid-to-bit-vector *unique-random-namespace*))
;=> 159134959691145724577639637335874542674

Converting a UUID to byte-array reresentation with UNICLY::UUID-TO-BYTE-ARRAY:

UNICLY> (unicly::uuid-to-byte-array *unique-random-namespace*)
;=> #(119 184 71 69 171 19 73 198 143 220 154 250 171 197 28 82)

Converting a UUID to byte-array reresentation with UNICLY::UUID-TO-BYTE-ARRAY
then converting that to a bit-vector:

UNICLY> (uuid-byte-array-to-bit-vector (unicly::uuid-to-byte-array *unique-random-namespace*))
;=> #*01110111101110000100011101000101101010110001001101001001110001101000111111011100100110101111101010101011110001010001110001010010

Note, above when converting the UUID object to a byte-array we used the internal
symbol UNICLY::UUID-TO-BYTE-ARRAY however the preferred interface for retrieving
the byte-array representation of a UUID object is UUID:GET-NAMESPACE-BYTES.  The
symbol UNICLY::UUID-TO-BYTE-ARRAY is not exported by Unicly b/c its
implementation conflicts with UUID:UUID-TO-BYTE-ARRAY (the two functions access
differently named slot values of their respective base classes
UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER vs. UUID:UUID).

Testing if a UUID object is UUID-EQL to itself:

UNICLY> (uuid-eql *unique-random-namespace* *unique-random-namespace*)
;=> T

Testing if a UUID object is UUID-EQL to its bit-vector representation:

UNICLY> (uuid-eql *unique-random-namespace* (uuid-to-bit-vector *unique-random-namespace*))
;=> T

Testing if a UUID object is UUID-EQL to a copy of itself as per UUID-COPY-UUID:

UNICLY> (let ((copy (uuid-copy-uuid *unique-random-namespace*)))
          (uuid-eql copy *unique-random-namespace*))
;=> T

Testing if a UUID object is UUID-EQL to its byte-array representation.
Note, this is likely to change in future versions!

UNICLY> (uuid-eql (uuid-to-byte-array *unique-random-namespace*)
                  *unique-random-namespace*)
;=> NIL

Testing if two UUID bit-vector representations are UUID-BIT-VECTOR-EQL:

UNICLY> (uuid-bit-vector-eql 
         (uuid-to-bit-vector *unique-random-namespace*)
         (uuid-byte-array-to-bit-vector (unicly::uuid-to-byte-array *unique-random-namespace*)))
;=>T

Testing if two UUID bit-vector representations are UUID-EQL:

UNICLY> (uuid-eql 
         (uuid-to-bit-vector *unique-random-namespace*)
         (uuid-byte-array-to-bit-vector (unicly::uuid-to-byte-array *unique-random-namespace*)))
;=> T

Note, we can also test if two UUID bit-vector representations are CL:EQUAL.
We can not do the same for two UUID byte-array representations, instead we must
use CL:EQUALP:

UNICLY> (equal
         (uuid-to-bit-vector (make-v5-uuid *unique-random-namespace* "bubba"))
         (uuid-to-bit-vector (make-v5-uuid *unique-random-namespace* "bubba"))) 
;=> T

UNICLY> (equal
         (uuid-to-bit-vector (make-v5-uuid *unique-random-namespace* "bubba"))
         (uuid-to-bit-vector (make-v5-uuid *unique-random-namespace* "NOT-A-bubba")))
;=> NIL

UNICLY> (equal
         (uuid-get-namespace-bytes (make-v5-uuid *unique-random-namespace* "bubba"))
         (uuid-get-namespace-bytes (make-v5-uuid *unique-random-namespace* "bubba")))
;=> NIL

UNICLY> (equalp
         (uuid-get-namespace-bytes (make-v5-uuid *unique-random-namespace* "bubba"))
         (uuid-get-namespace-bytes (make-v5-uuid *unique-random-namespace* "bubba")))
;=> T

UNICLY> (equalp
         (uuid-get-namespace-bytes (make-v5-uuid *unique-random-namespace* "bubba"))
         (uuid-get-namespace-bytes (make-v5-uuid *unique-random-namespace* "NOT-A-BUBBA")))
;=> NIL

Roundtripping UUID representations:
 uuid -> bit-vector -> uuid -> byte-array -> bit-vector -> uuid 
  -> byte-array -> uuid -> uuid-string-36 -> uuid

First we verify the identity of the name "bubba" in the *uuid-namespace-dns*
namespace:

UNICLY> (make-v5-uuid *uuid-namespace-dns* "bubba")
;=> eea1105e-3681-5117-99b6-7b2b5fe1f3c7

Does the roundtripping return an equivalent object?:

UNICLY> (make-uuid-from-string
         (uuid-princ-to-string
          (uuid-from-byte-array
           (uuid-to-byte-array
            (uuid-from-bit-vector
             (uuid-byte-array-to-bit-vector
              (uuid-to-byte-array 
               (uuid-from-bit-vector 
                (uuid-to-bit-vector 
                 (make-v5-uuid *uuid-namespace-dns* "bubba"))))))))))
;=> eea1105e-3681-5117-99b6-7b2b5fe1f3c7

Comparing return value of UUID-EQL with CL builtin operators CL:EQ, CL:EQL,
CL:EQUAL, CL:EQUALP, and CL:SXHASH:

UNICLY> (let* ((uuid-1    (make-v5-uuid *uuid-namespace-dns* "bubba"))
               (uuid-1-bv (uuid-to-bit-vector (make-v5-uuid *uuid-namespace-dns* "bubba")))
               (uuid-2    (uuid-from-bit-vector uuid-1-bv)))
          (list :uuid-eql (uuid-eql uuid-1 uuid-2)
                :eq       (eq uuid-1 uuid-2)
                :eql      (eql uuid-1 uuid-2) 
                :equal    (equal uuid-1 uuid-2)
                :equalp   (equalp uuid-1 uuid-2)
                :sxhash   (list (sxhash uuid-1) (sxhash uuid-2))))
;=> (:UUID-EQL T :EQ NIL :EQL NIL :EQUAL NIL :EQUALP NIL :SXHASH (121011444 363948070))

Get the integer version of a UUID object:

UNICLY> (uuid-version-uuid *unique-random-namespace*)
;=> 4

UNICLY> (uuid-version-uuid (make-v5-uuid *unique-random-namespace* "bubba-8"))
;=> 5

Using a predicate to test the version of a UUID object:

UNICLY> (uuid-bit-vector-v4-p (uuid-to-bit-vector *unique-random-namespace*))
;=> T
 
UNICLY> (uuid-bit-vector-v5-p (uuid-to-bit-vector *unique-random-namespace*))
;=> NIL

Generating an instance of the null-uuid:

UNICLY> (make-null-uuid)
;=> 00000000-0000-0000-0000-000000000000

(Note, some special mojo occurs behind the curtains to ensure unique identity
for the null-uuid b/c the CL:SXHASH of the null-uuid is an intransient value).

MAKE-NULL-UUID is the preferred interface for accessing the null-uuid, we can
test if its return-value is an instance of class
UNIQUE-UNIVERSAL-IDENTIFIER-NULL with UNIQUE-UNIVERSAL-IDENTIFIER-NULL-P:

UNICLY> (unique-universal-identifier-null-p (make-null-uuid))
;=> T

Get the version of the null-uuid. Note, the CL:NTH-VALUE 1 can be checked to
verify that every bit of the UUID object is 0 (as opposed to an object with a
partial bit signature at bits 48-51 mimicing that of the null-uuid):

UNICLY> (uuid-version-uuid (make-null-uuid))
;=>  0, UNICLY::NULL-UUID

Testing if the null-uuid is UUID-EQL to itself:

UNICLY> (uuid-eql (make-null-uuid) (make-null-uuid))
;=> T

The UUID is sometimes referenced as having an 8:4:4:4:12 hex string representation. 
We refer to this representation as a UUID object with type UUID-HEX-STRING-36.

However, such references imply a string-centric view-point of the UUID when
really it is much saner to see the uuid as a sequence of bits or bytes.

Following table illustrates the components of a UUID as a bit/byte field. 
Note, it will not display correctly in a text-editor word/line wrapping is
enabled and/or your display is unable to lines of render text out to 140 columns
:{

The UUID as bit field:

 WEIGHT   INDEX      OCTETS                     BIT-FIELD-PER-OCTET
    4  | (0  31)  | 255 255 255 255         | #*11111111 #*11111111 #*11111111 #*11111111  | %uuid_time-low               | uuid-ub32
    2  | (32 47)  | 255 255                 | #*11111111 #*11111111                        | %uuid_time-mid               | uuid-ub16
    2  | (48 63)  | 255 255                 | #*11111111 #*11111111                        | %uuid_time-high-and-version  | uuid-ub16
    1  | (64 71)  | 255                     | #*11111111                                   | %uuid_clock-seq-and-reserved | uuid-ub8
    1  | (72 79)  | 255                     | #*11111111                                   | %uuid_clock-seq-low          | uuid-ub8
    6  | (80 127) | 255 255 255 255 255 255 | #*11111111 #*11111111 #*11111111 #*11111111 #*11111111 #*11111111 | %uuid_node | uuid-ub48

The UUIDs bit-vector representation:

UNICLY> (uuid-to-bit-vector (make-v5-uuid *uuid-namespace-dns* "bubba"))
;=> #*11101110101000010001000001011110001101101000000101010001000101111001100110110110011110110010101101011111111000011111001111000111
;     !      !       !       !       !       !       !       !        !      !       !       !       !       !       !       !       !  
;     0      7       15      23      31      39      47      55       63     71      79      87      95      103     111     119     127
;      --1--   --2--   --3--   --4--   --5--   --6--   --7--    --8--   --9--   -10-   -11-     -12-    -13-    -14-    -15-    -16-  
;     |  time-low slot               | time-mid slot | time-high slot | rsvd |  low  |                node slot                      |

The UUIDs binary integer representation:

UNICLY> #b11101110101000010001000001011110001101101000000101010001000101111001100110110110011110110010101101011111111000011111001111000111
;=> 317192554773903544674993329975922389959

The byte-array reresentation of a UUIDs integer representation:

UNICLY> (uuid-integer-128-to-byte-array 317192554773903544674993329975922389959)
;=> #(238 161 16 94 54 129 81 23 153 182 123 43 95 225 243 199)
 
UNICLY> (uuid-to-byte-array (make-v5-uuid *uuid-namespace-dns* "bubba"))
;=> #(238 161 16 94 54 129 81 23 153 182 123 43 95 225 243 199)

The component octet bit-vector reresentation of a UUID:

UNICLY> (map 'list #'uuid-octet-to-bit-vector-8
             (uuid-to-byte-array (make-v5-uuid *uuid-namespace-dns* "bubba")))
;=> (#*11101110 #*10100001 #*00010000 #*01011110 #*00110110 #*10000001 #*01010001 #*00010111 
;    #*10011001 #*10110110 #*01111011 #*00101011 #*01011111 #*11100001 #*11110011 #*11000111)

Converting from UUID -> byte-array -> bit-vector:

UNICLY> (uuid-byte-array-to-bit-vector (uuid-to-byte-array (make-v5-uuid *uuid-namespace-dns* "bubba")))
;=> #*11101110101000010001000001011110001101101000000101010001000101111001100110110110011110110010101101011111111000011111001111000111

The upper bounds of a UUID in binary integer representation:

UNICLY> #b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
;=> 340282366920938463463374607431768211455
 
The number of unsigned bits used to represent the upper bounds of a UUIDs
integer representation:

UNICLY> (integer-length 340282366920938463463374607431768211455) 
;=> 128

The octet count of the upper bounds of a UUIDs integer representation:

UNICLY> (truncate (integer-length 340282366920938463463374607431768211455) 8)
;=> 16

The upper bounds of UUID in decimal integer representation (longform):

UNICLY> (format t "~R" 340282366920938463463374607431768211455)
;=> three hundred forty undecillion two hundred eighty-two decillion three hundred
;   sixty-six nonillion nine hundred twenty octillion nine hundred thirty-eight
;   septillion four hundred sixty-three sextillion four hundred sixty-three
;   quintillion three hundred seventy-four quadrillion six hundred seven trillion
;   four hundred thirty-one billion seven hundred sixty-eight million two hundred
;   eleven thousand four hundred fifty-five

Converting from a UUID bit-vector representation to an integer:

UNICLY> (uuid-bit-vector-to-integer (uuid-to-bit-vector (make-v5-uuid *uuid-namespace-dns* "bubba")))
;=> 317192554773903544674993329975922389959

Converting from a UUID byte-array representation to an integer:

UNICLY> (uuid-integer-128-to-byte-array 317192554773903544674993329975922389959)
;=> #(238 161 16 94 54 129 81 23 153 182 123 43 95 225 243 199)

Converting from a UUID byte-array representation to a  UUID integer representation:

UNICLY> (uuid-byte-array-16-to-integer 
         (uuid-integer-128-to-byte-array 317192554773903544674993329975922389959))
;=> 317192554773903544674993329975922389959

Converting from a UUID integer representation to a UUID bit-vector representation:

UNICLY> (uuid-integer-128-to-bit-vector 317192554773903544674993329975922389959)
;=> #*11101110101000010001000001011110001101101000000101010001000101111001100110110110011110110010101101011111111000011111001111000111

Testing if two UUIDs are UUID-BIT-VECTOR-EQL where the first is coerced to a
bit-vector from a UUID object and the second is coerced to a bit-vector from a
UUID integer representation:

UNICLY> (uuid-bit-vector-eql (uuid-to-bit-vector (make-v5-uuid *uuid-namespace-dns* "bubba")) 
                             (uuid-integer-128-to-bit-vector 317192554773903544674993329975922389959))
;=> T

Testing if two UUIDs are UUID-BIT-VECTOR-EQL where the first is coerced to a
bit-vector from UUID integer representation and the second is coerced to a
bit-vector from a UUID byte-array representation:

UNICLY> (uuid-bit-vector-eql (uuid-integer-128-to-bit-vector 317192554773903544674993329975922389959)
                             (uuid-byte-array-to-bit-vector (uuid-integer-128-to-byte-array 317192554773903544674993329975922389959)))
;=> T


    
Differences between the Unicly system and the uuid system:

Unicly has a similar interface to Boian Tzonev's Common Lisp library uuid: 
 :SEE (URL `https://github.com/dardoria/uuid')

Indeed, the core of Unicly is derived from Tzonev's uuid codebase.

However, Unicly deviates in some not insignificant ways from Tzonev's uuid and
while we have made some attempt to create a compatibility layer between the two
libraries the UUID objects generated with Unicly can not be used interchangeably
with those of Tzonev's uuid.

Some notable differences between Unicly and Tzonev's uuid:

 - Unicly is developed on SBCL 

   * Many routines are targeted towards making use of SBCL specific features.

   * It is highly declaration bound and inlined.

   * I do not test on implementations other than SBCL, but code for generating
     v3, v4, and v5 UUIDs *should* run portably on other Common Lisps ;}

 - Unicly is developed primarily for speedy minting of v3 and v5 UUIDs.
   On an x86-32 SBCL we have found Unicly's minting of v3 and v5 UUIDs to be
   significantly faster (at least 3-5x) than equivalent code from uuid.
   See unicly/unicly-timings.lisp for some timing comparisons.
   
   * Unicly is not particlulary faster than uuid when minting v4 UUIDS. 
   This is to be expected as both systems depend on frobbing *random-state*
   and there is little room for optimization beyond some internal declarations.
   
   * Unicly does however have different performace characteristcs when comparing
   timings of UNICLY:MAKE-V5-UUID with UUID:MAKE-V5-UUID. 

   Following timings were made using functionally identical namespaces for 1mil
   invocations on an x86-32 SBCL.

   Name components were taken from an array of 1mil elements where each element was
   a randomly generated string and where each string was between 1-36 characters long
   and where each character of the string was a randomly chosen UTF-8 characater
   (pulled from a constrained set of 360). With each invocation having the basic form:

    (unicly:make-v5-uuid  )
    (uuid:make-v5-uuid  )

    unicly:make-v5-uuid 
     18.251 seconds of real time
     54,614,814,653 processor cycles
     961,242,536 bytes consed
   
   uuid:make-v5-uuid
     57.404 seconds of real time
     171,781,583,768 processor cycles
     5,356,186,536 bytes consed
   
   The above ratios are similar for the equivalent MAKE-V3-UUID functions.
   
   Other significant performace differences can be seen between Unicly and uuid
   around the respective system's UUID-TO-BYTE-ARRAY, UUID-FROM-BYTE-ARRAY,
   MAKE-UUID-FROM-STRING functions.
   
   However, Unicly's biggest performance gains don't become apparent until using
   Unicly for equivalence tests and hash-table lookups using Unicly's extended
   interface as provided by UUID-EQL, UUID-BIT-VECTOR-EQL, etc.

 - Unicly is extended with support for creating/storing/(de)serializing UUID
   objects as bit vectors.

   * For persistence libraries which make use of hash-tables to store their keys
     as UUID objects in hex-string-36 representation there are some potentially big
     gains to be had by moving to a bit-vector base UUID representation.
   
     For example, on SBCL it is possible to SB-EXT:DEFINE-HASH-TABLE-TEST which
     tests for UUID bit-vector equivalence using UUID-BIT-VECTOR-EQL instead of
     CL:EQUAL and CL:EQUALP.
     (Underneath the covers UUID-BIT-VECTOR-EQL invokes SB-INT:BIT-VECTOR-=
      A nearly equivalent routine is provided for other CLs)

 - Unicly is extended with support for preserving identity of the null-uuid.
   This feature is specified in RFC 4122.

 - Unicly prints UUID string representations in case-significant form.
   This feature is specified in RFC 4122 Section 3. "Namespace Registration Template"
   as follows:

    ,----
    | The hexadecimal values "a" through "f" are output as lower case characters
    | and are case insensitive on input.
    `----

 - Unicly defines its base UUID class as UNIQUE-UNIVERSAL-IDENTIFIER instead of
   as the class UUID.

 - Unicly does not expose accessors for the slots of the UUID class
   UNIQUE-UNIVERSAL-IDENTIFIER.

 - Unicly slot-names for the base class UNIQUE-UNIVERSAL-IDENTIFIER are strongly
   namespaced with "%uuid_". This intent here is twofold:

   * Our opinion is that UUID identity should be considered immutable once minted.
     There should be no need for user code to directly modify a UUIDs slot
     values. Obfuscating easy access to the class slots of
     UNIQUE-UNIVERSAL-IDENTIFIER helps prevent this.

    * Because the Unicly interface is similar to that of the uuid library we've
      attempted to prevent trivial visual namespace collision with the slots of
      the uuid library.  Projects using both Unicly and the uuid library may
      benefit from being able to easily distinguish among the two.

 - Unicly's printing of a UUIDs string representation is not always conformant
   with ANSI spec.

    * The UUID CL:PRINT-OBJECT method for the class UNIQUE-UNIVERSAL-IDENTIFIER is
      not wrapped around PRINT-UNREADABLE-OBJECT.

 - Unicly's interface is extensively documented.

 - Unicly's source-code is commented with references to the relevant portions of
   RFC 4122.

 - Unicly does not have a dependency on trivial-utf-8

   * SBCL users can use internal features (assuming a Unicode enabled SBCL)

   * non-SBCL code can (and should) use flexi-streams instead 

 - Unicly is not released under an LLGPL licenses.

   * If licensing issues are a concern in your project please take a moment to
     investigate unicly/LICENSE.txt

    Although Unicly is initially derived from Tzonev's uuid library we note that
    significant portions of that library were in turn strongly derived from the
    non-normative reference implementation source code included of RFC4122 Appendix
    C as a wholly functional C language source code implementation of RFC4122.

    We believe the original RFC reference implementation and license have clear
    precedent in lieu of the later LLGPL and believe it reasonable to revert to the
    spirit of the original permissive and non-LLGPL'd license included of RFC4122.
   
 - Unicly is not targeted for generation of version 1 UUIDs (e.g. time based).

   The general implementation strategy for minting v1 UUID is reliant on
   interrogation of the system's underlying hardware and clock setting [1].
   When this is the strategy taken we have found that:

    * It requires platform and implementation specific code;

    * Minting version 1 UUIDs requires interrogating the MAC address of an
      Ethernet device;

    * Minting version 1 UUIDs requires interrogating the system clock -- there
      are in general some notoriously nasty bugs which spring from reliance on
      the value of the system clock e.g. cross-platform multi-boot systems...

    * Minting version 1 UUIDs is slow;

    * There is no portably universal mechanism for generation of version 1 UUIDs
      Some implementations use the hardware for seed value others use a random-number.

    * The uniqueness of version 1 UUIDs is not nearly as robust as the v3, v4,
      v5 variants. There are numerous mechanisms by which a v1 UUID can
      become corrupted which simply do not affect the others.

   [1]  RFC 4122 Section 4.5 "Node IDs that Do Not Identify the Host"
   Suggests that a v1 UUID may also be minted from a "47-bit cryptographic
   quality random number" by using it as the bottom 47 bits of the UUID Node id
   and setting the LSB of the first octet of the UUID node id to 1.
   Unfortunately, when attempting to implement this alternative strategy we found that
   Tzonev's uuid library has what we believe to be a bug in uuid:get-node-id in
   that it sets bit 0 of the the LS-Byte of a 48bit integer with:

     (setf node (dpb #b01 (byte 8 0) (random #xffffffffffff *random-state-uuid*)))

   Apparently, there is some confusion around the RFC's reference to the
   unicast/multicast bit, instead of the arguably more correct local/global bit.
   
   As it is now, when using Tzonev's uuid one can not reliably inspect a v1 UUID
   for its version because the bits are in the wrong sequence and disambiguation
   of of the various v1, v2, v3, v4, and v5 UUIDs is impossible.
   
  :SEE unicly/unicly-compat.lisp for additional details/discussion.

   We could attempt to accommodate this and propagate the error onward or do the
   prudent thing and simply rely on v3, v4, v5 UUIDs instead.

Examples of Common Lisp libraries which make use of UUIDs:

(URL `https://raw.github.com/kraison/vivace-graph-v2/master/triples.lisp')
(URL `https://raw.github.com/lisp/de.setf.resource/master/resource-object.lisp')
(URL `https://raw.github.com/dto/blocky/master/prototypes.lisp')
(URL `https://raw.github.com/fons/cl-mongo/master/src/bson-oid.lisp')
(URL `git://github.com/kraison/kyoto-persistence.git')

An Emacs lisp implementation of RFC 4122 UUID generation:

(URL `https://github.com/kanru/uuid-el')

RFC 4122:

(URL `http://www.ietf.org/rfc/rfc4122.txt')
(URL `http://tools.ietf.org/pdf/rfc4122')


;;; ==============================
;;; EOF


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 unicly

Maintainer

MON KEY – monkey@sandpframing.com

License

MIT

Description

UUID Generation per RFC 4122

Long Description

UUID implementation for Common Lisp as per RFC 4122

Version

2011.8.31

Dependencies
Source

unicly.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 unicly.asd

Location

unicly.asd

Systems

unicly (system)

Packages

unicly-asd

Internal Definitions

*author-maintainer-contact* (special variable)


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

3.1.2 unicly/package.lisp

Parent

unicly (system)

Location

package.lisp

Packages

unicly


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

3.1.3 unicly/unicly-specials.lisp

Dependency

package.lisp (file)

Parent

unicly (system)

Location

unicly-specials.lisp

Exported Definitions
Internal Definitions

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

3.1.4 unicly/unicly-bridge.lisp

Dependency

unicly-specials.lisp (file)

Parent

unicly (system)

Location

unicly-bridge.lisp

Internal Definitions

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

3.1.5 unicly/unicly-utils.lisp

Dependency

unicly-bridge.lisp (file)

Parent

unicly (system)

Location

unicly-utils.lisp

Internal Definitions

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

3.1.6 unicly/unicly-macros.lisp

Dependency

unicly-utils.lisp (file)

Parent

unicly (system)

Location

unicly-macros.lisp

Internal Definitions

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

3.1.7 unicly/unicly-types.lisp

Dependency

unicly-macros.lisp (file)

Parent

unicly (system)

Location

unicly-types.lisp

Exported Definitions
Internal Definitions

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

3.1.8 unicly/unicly-class.lisp

Dependency

unicly-types.lisp (file)

Parent

unicly (system)

Location

unicly-class.lisp

Exported Definitions
Internal Definitions

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

3.1.9 unicly/unicly-conditions.lisp

Dependency

unicly-class.lisp (file)

Parent

unicly (system)

Location

unicly-conditions.lisp

Internal Definitions

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

3.1.10 unicly/unicly-integers.lisp

Dependency

unicly-conditions.lisp (file)

Parent

unicly (system)

Location

unicly-integers.lisp

Internal Definitions

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

3.1.11 unicly/unicly-byte-arrays.lisp

Dependency

unicly-integers.lisp (file)

Parent

unicly (system)

Location

unicly-byte-arrays.lisp

Exported Definitions
Internal Definitions

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

3.1.12 unicly/unicly-bit-vectors.lisp

Dependency

unicly-byte-arrays.lisp (file)

Parent

unicly (system)

Location

unicly-bit-vectors.lisp

Exported Definitions
Internal Definitions

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

3.1.13 unicly/unicly-null-check.lisp

Dependency

unicly-bit-vectors.lisp (file)

Parent

unicly (system)

Location

unicly-null-check.lisp

Internal Definitions

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

3.1.14 unicly/unicly.lisp

Dependency

unicly-null-check.lisp (file)

Parent

unicly (system)

Location

unicly.lisp

Exported Definitions
Internal Definitions

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

3.1.15 unicly/unicly-string-uuid.lisp

Dependency

unicly.lisp (file)

Parent

unicly (system)

Location

unicly-string-uuid.lisp

Exported Definitions

make-uuid-from-string (function)

Internal Definitions

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

3.1.16 unicly/unicly-uuid-version.lisp

Dependency

unicly-string-uuid.lisp (file)

Parent

unicly (system)

Location

unicly-uuid-version.lisp

Exported Definitions

uuid-version-uuid (function)

Internal Definitions

%uuid-uuid-version-if (function)


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

3.1.17 unicly/unicly-hash-table.lisp

Dependency

unicly-uuid-version.lisp (file)

Parent

unicly (system)

Location

unicly-hash-table.lisp

Exported Definitions
Internal Definitions

+%%uuid-sxhash-truncating-node%%+ (constant)


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

3.1.18 unicly/unicly-io.lisp

Dependency

unicly-hash-table.lisp (file)

Parent

unicly (system)

Location

unicly-io.lisp

Internal Definitions

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

3.1.19 unicly/unicly-extend.lisp

Dependency

unicly-io.lisp (file)

Parent

unicly (system)

Location

unicly-extend.lisp

Internal Definitions

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

3.1.20 unicly/unicly-docs.lisp

Dependency

unicly-extend.lisp (file)

Parent

unicly (system)

Location

unicly-docs.lisp


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

4 Packages

Packages are listed by definition order.


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

4.1 unicly-asd

Source

unicly.asd

Use List
Internal Definitions

*author-maintainer-contact* (special variable)


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

4.2 unicly

Source

package.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Special variables

Special Variable: *uuid-namespace-dns*

A DNS namespace as provided with RFC4122 Appendix C. "Some Name Space IDs".

It is suggested that this may be used as the NAMESPACE arg when generating v3
and v5 UUIDs where NAME is a string designating a FQDN (Fully-Qualified Domain Name).

:EXAMPLE

(unique-universal-identifier-p *uuid-namespace-dns*)

The default value of this namespace is generated from the hexadecimal integers provided for ‘NameSpace_DNS‘ page 29 of the appendix.

These are:
#x6ba7b810 ;; uuid-ub32
#x9dad ;; uuid-ub16
#x11d1 ;; uuid-ub16
#x80 ;; uuid-ub8
#xb4 ;; uuid-ub8
#x00 #xc0 #x4f #xd4 #x30 #xc8 ;; uuid-ub48

With the string representation: "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
:SEE-ALSO ‘make-v3-uuid’, ‘make-v5-uuid’, ‘make-v4-uuid’.

Package

unicly

Source

unicly-specials.lisp (file)

Special Variable: *uuid-namespace-oid*

An OID namespace as provided with RFC4122 Appendix C. "Some Name Space IDs".

It is suggested that this may be used as the NAMESPACE arg when generating v3 and v5 UUIDs where NAME is a string designating an ISO OID .

:EXAMPLE

(unique-universal-identifier-p *uuid-namespace-oid*)

The default value for this namespace is generated from the hexadecimal integers provided with RFC4122 Appendix C. - "Some- Name Space IDs" page 29.

#x6ba7b812 ;; uuid-ub32
#x9dad ;; uuid-ub16
#x11d1 ;; uuid-ub16
#x80 ;; uuid-ub8
#xb4 ;; uuid-ub8
#x00 #xc0, #x4f, #xd4, #x30, #xc8 ;; uuid-ub48

With the string representaton: "6ba7b812-9dad-11d1-80b4-00c04fd430c8"

:SEE (URL ‘http://www.techabulary.com/o/oid/’)

:SEE-ALSO ‘make-v3-uuid’, ‘make-v5-uuid’, ‘make-v4-uuid’.

Package

unicly

Source

unicly-specials.lisp (file)

Special Variable: *uuid-namespace-url*

An URL namespace as provided with RFC4122 Appendix C. "Some Name Space IDs".

It is suggested that this may be used as the NAMESPACE arg when generating v3 and v5 UUIDs where NAME is a string designating an URL (Universal Resource Locator).

:EXAMPLE

(unique-universal-identifier-p *uuid-namespace-url*)

The default value for this namespace is generated from the hexadecimal integers provided with RFC4122 Appendix C. - "Some- Name Space IDs" page 29.

These are:
#x6ba7b811 ;; uuid-ub32
#x9dad ;; uuid-ub16
#x11d1 ;; uuid-ub16
#x80 ;; uuid-ub8
#xb4 ;; uuid-ub8
#x00 #xc0, #x4f, #xd4, #x30, #xc8 ;; uuid-ub48

With the string representation: "6ba7b811-9dad-11d1-80b4-00c04fd430c8"

:SEE-ALSO ‘make-v3-uuid’, ‘make-v5-uuid’, ‘make-v4-uuid’.

Package

unicly

Source

unicly-specials.lisp (file)

Special Variable: *uuid-namespace-x500*

An x500 namespace as provided with RFC4122 Appendix C. "Some Name Space IDs".

It is suggested that this may be used as the NAMESPACE arg when generating v3 and v5 UUIDs where NAME is a string designating an an X.500 Distinguished Name in DER (Distinguished Encoding Rules) or a text output format.

:EXAMPLE

(unique-universal-identifier-p *uuid-namespace-x500*)

The default value for this namespace is generated from the hexadecimal integers provided with RFC4122 Appendix C. - "Some- Name Space IDs" page 29.

#x6ba7b812 ;; uuid-ub32
#x9dad ;; uuid-ub16
#x11d1 ;; uuid-ub16
#x80 ;; uuid-ub8
#xb4 ;; uuid-ub8
#x00 #xc0, #x4f, #xd4, #x30, #xc8 ;; uuid-ub48

With the string representaton: "6ba7b812-9dad-11d1-80b4-00c04fd430c8"

:SEE (URL ‘http://en.wikipedia.org/wiki/X.500’)

:SEE (URL ‘http://luca.ntop.org/Teaching/Appunti/asn1.html’) esp. Section 6.

:SEE-ALSO ‘make-v3-uuid’, ‘make-v5-uuid’, ‘make-v4-uuid’.

Package

unicly

Source

unicly-specials.lisp (file)


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

5.1.2 Functions

Function: make-hash-table-uuid &key SIZE REHASH-SIZE REHASH-THRESHOLD WEAKNESS SYNCHRONIZED

Return a hash-table specialized to hold UUIDs as keys.

On SBCL this this is a hash-table with ‘uuid-eql’ as ‘cl:hash-table-test’.

Keyword :SYNCHRONIZED when non-nile indicates hash-table may have multiple concurrent readers. :EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘sb-ext:with-locked-hash-table’.

Package

unicly

Source

unicly-hash-table.lisp (file)

Function: make-null-uuid ()

Generate a NULL UUID.

Per RFC4122 Setion 4.1.7. "Nil UUID":
The nil UUID is special form of UUID specified to have all 128 bits set to zero.

Return value is an instance of ‘unique-universal-identifier’ with all slots defaulted to 0.

Return value has the format:

00000000-0000-0000-0000-000000000000

:EXAMPLE

(make-null-uuid)

:NOTE Two null-uuids do not share identity:

(eq (make-instance ’unique-universal-identifier)
(make-instance ’unique-universal-identifier))

(eql (make-instance ’unique-universal-identifier)
(make-instance ’unique-universal-identifier))

(equal (make-instance ’unique-universal-identifier)
(make-instance ’unique-universal-identifier))

(equalp (make-instance ’unique-universal-identifier)
(make-instance ’unique-universal-identifier))

However, we can test with ‘uuid-eql’ if they have the same representation in uuid-bit-vector-128 format:

(uuid-eql
(make-instance ’unique-universal-identifier)
(make-instance ’unique-universal-identifier))

:SEE-ALSO ‘uuid-bit-vector-128-zeroed’.

Package

unicly

Source

unicly.lisp (file)

Function: make-uuid-from-string UUID-OR-HEX-STRING-36

Create an instance of class UNIQUE-UNIVERSAL-IDENTIFIER from UUID-OR-HEX-STRING-36.

UUID-OR-HEX-STRING-36 is an object of type UNIQUE-UNIVERSAL-IDENTIFIER or UUID-OR-HEX-STRING-36. It should satisfy one of ‘unique-universal-identifier-p’ or
‘uuid-hex-string-36-p’, an error is signaled if not.

:EXAMPLE

(make-uuid-from-string "6ba7b810-9dad-11d1-80b4-00c04fd430c8")

(make-uuid-from-string *uuid-namespace-dns*)

(make-uuid-from-string (uuid-princ-to-string *uuid-namespace-dns*))

(equal (make-uuid-from-string *uuid-namespace-dns*)
(make-uuid-from-string (uuid-princ-to-string *uuid-namespace-dns*)))

;; :Following successfully signals an error:

(make-uuid-from-string "Q6ba7b810-9dad-11d1-80b4-00c04fd430c8")

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-string-uuid.lisp (file)

Function: make-v3-uuid NAMESPACE NAME

Generate an RFC4122 version 3 (named based MD5) UUID for NAME in NAMESPACE.

Return value is an instance of the UNIQUE-UNIVERSAL-IDENTIFIER class.

NAMESPACE is a UUID namespace object.

NAME is a string.

:EXAMPLE

(make-v3-uuid *uuid-namespace-dns* "bubba")

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly.lisp (file)

Function: make-v4-uuid ()

Return a version 4 (random) UUID.

Return value is an instance of the UNIQUE-UNIVERSAL-IDENTIFIER class.

:EXAMPLE

{ ... <EXAMPLE> ... }

A v4 UUID is one generatied UUIDs from truly-random or pseudo-random numbers.

,—- RFC4122 Section 4.4. "Creating UUIDs from Truly-Random/Pseudo-Random Numbers" |
| The algorithm is as follows:
|
| 1) Set the two most significant bits (bits 6 and 7) of the
| clock_seq_hi_and_reserved to zero and one, respectively.
| ‘-> Slot ‘%uuid_clock-seq-and-reserved’
| :NOTE Steps 7 and 8 for v3 and v5 with ‘%uuid_clock-seq-and-reserved-request’ |
| 2) Set the four most significant bits (bits 12 through 15) of the
| time_hi_and_version field to the 4-bit version number from Section 4.1.3.
| ‘-> Slot ‘%uuid_time-high-and-version’ e.g. #*0100
| :NOTE Correspond with step 6 for v3 and v5 which sets top bits
| #*01010 for SHA1 or #*0011 for MD5 with ‘%uuid_time-high-and-version-request’ |
| 3) Set all the other bits to randomly (or pseudo-randomly) chosen
| values.
| ‘-> Slots ‘%uuid_time-low’, ‘%uuid_time-mid’, ‘%uuid-clock-seq-low’, ‘%uuid_node’ ‘—-

:SEE-ALSO ‘make-v3-uuid’, ‘make-v5-uuid’, ‘make-v1-uuid’, ‘make-null-uuid’, ‘*random-state-uuid*’, ‘cl:random’.

Package

unicly

Source

unicly.lisp (file)

Function: make-v5-uuid NAMESPACE NAME

Generates an RFC4122 version 5 (nambe based SHA1) UUID with NAME in NAMESPACE.

Return value is an instance of the class UNIQUE-UNIVERSAL-IDENTIFIER.

NAMESPACE is a UUID namespace object.

NAME is a string.

:EXAMPLE

(make-v5-uuid *uuid-namespace-dns* "bubba")

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly.lisp (file)

Function: sxhash-uuid UUID

Return the ‘sxhash’ of UUID’s representation as an object of type ‘uuid-bit-vector-128’.

UUID is an instance of the class ‘unique-universal-identifier’.

:EXAMPLE

(sxhash-uuid (make-v4-uuid))

(sxhash-uuid (make-v3 uuid *uuid-namespace-dns* "bubba"))

(sxhash-uuid (make-v5-uuid *uuid-namespace-dns* "bubba"))

(let ((v4-instance (make-v4-uuid))
(v5-instance (make-v5-uuid *uuid-namespace-dns* "bubba"))
(v3-instance (make-v3-uuid *uuid-namespace-dns* "bubba")))
(and (eq (sxhash-uuid v5-instance)
(sxhash-uuid (uuid-copy-uuid v5-instance)))
(eq (sxhash-uuid v3-instance)
(sxhash-uuid (uuid-copy-uuid v3-instance)))
(eq (sxhash-uuid v4-instance)
(sxhash-uuid (uuid-copy-uuid v4-instance)))))

:SEE-ALSO ‘uuid-eql’, ‘uuid-copy-uuid’, ‘uuid-to-bit-vector’, ‘sb-int:bit-vector-=’.

Package

unicly

Source

unicly-hash-table.lisp (file)

Function: unique-universal-identifier-null-p OBJECT

Whether object is an instance of the class
‘unicly::unique-universal-identifier-null’ and its value is ‘cl:eq’ that of
special variable ‘unicly::*uuid-null-uuid*’.

:EXAMPLE

(unique-universal-identifier-null-p *uuid-null-uuid*)

(unique-universal-identifier-null-p (make-null-uuid))

(type-of (make-instance ’unique-universal-identifier-null))

;; Following both fail successfully:

(unique-universal-identifier-null-p (make-instance ’unicly::unique-universal-identifier-null))

(unique-universal-identifier-null-p (make-instance ’unicly::unique-universal-identifier))

:SEE-ALSO ‘unicly:unique-universal-identifier-p’.

Package

unicly

Source

unicly-class.lisp (file)

Function: uuid-as-urn-string STREAM UUID

Print UUID as a URN (Universal Resource Name) to STREAM.

Return value has the format:

urn:uuid:<UUID>

UUID is an instance of ‘unique-universal-identifier’ class.

STREAM is an output-stream of type ‘stream-or-boolean-or-string-with-fill-pointer’.

:EXAMPLE

(string= (uuid-as-urn-string nil (make-null-uuid)) "urn:uuid:00000000-0000-0000-0000-000000000000")

:NOTE Per RFC4122 Section 3. "Namespace Registration Template"
,—-
| The hexadecimal values "a" through "f" are output as
| lower case characters and are case insensitive on input.
‘—-

:SEE-ALSO ‘make-uuid-from-string’, ‘uuid-print-bytes’,
‘uuid-print-bytes-to-string’, ‘uuid-princ-to-string’,
‘uuid-string-parse-integer’.

Package

unicly

Source

unicly.lisp (file)

Function: uuid-bit-vector-128-p MAYBE-OBJECT-OF-TYPE
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-bit-vector-eql UUID-BV-A UUID-BV-B
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-bit-vector-null-p BIT-VECTOR-MAYBE-NULL

Whether BIT-VECTOR-MAYBE-NULL is of type ‘unicly:uuid-bit-vector-null’.

:EXAMPLE

(uuid-bit-vector-null-p (uuid-bit-vector-128-zeroed))

(uuid-bit-vector-null-p (make-array 128 :element-type ’bit :initial-element 1))

(null (uuid-bit-vector-null-p (uuid-byte-array-16-zeroed)))

:SEE-ALSO ‘unicly:uuid-bit-vector-eql’, ‘unicly:uuid-bit-vector-128-zeroed’, ‘unicly:uuid-bit-vector-128’, ‘unicly:uuid-bit-vector-128-p’.

Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-bit-vector-to-byte-array UUID-BV-128

Convert UUID-BV-128 to a UUID-BYTE-ARRAY-16.

Arg UUID-BV-128 should satisfy ‘uuid-bit-vector-128-check-type’.

:EXAMPLE

(equalp
(uuid-bit-vector-to-byte-array (uuid-to-bit-vector (make-v5-uuid *uuid-namespace-dns* "bubba"))) (uuid-to-byte-array (make-v5-uuid *uuid-namespace-dns* "bubba")))

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-bit-vector-v3-p UUID-BIT-VECTOR

<DOCSTR>

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘uuid-version-bit-vector’, ‘uuid-bit-vector-v3-p’, ‘uuid-bit-vector-v4-p’ ‘uuid-bit-vector-v5-p’, ‘uuid-bit-vector-128’, ‘uuid-eql’.

Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-bit-vector-v4-p UUID-BIT-VECTOR

<DOCSTR>

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘uuid-version-bit-vector’, ‘uuid-bit-vector-v3-p’, ‘uuid-bit-vector-v4-p’ ‘uuid-bit-vector-v5-p’, ‘uuid-bit-vector-128’, ‘uuid-eql’.

Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-bit-vector-v5-p UUID-BIT-VECTOR

<DOCSTR>

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘uuid-version-bit-vector’, ‘uuid-bit-vector-v3-p’, ‘uuid-bit-vector-v4-p’ ‘uuid-bit-vector-v5-p’, ‘uuid-bit-vector-128’, ‘uuid-eql’.

Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-byte-array-16-p MAYBE-OBJECT-OF-TYPE

Whether MAYBE-UUID-BYTE-ARRAY-16 is of type ‘uuid-byte-array-16’.

Return T when MAYBE-UUID-BYTE-ARRAY-16 has the type signature:

(simple-array (unsigned-byte 8) (16))

:EXAMPLE

(uuid-byte-array-16-p (uuid-to-byte-array *uuid-namespace-dns*))

:SEE-ALSO ‘uuid-hex-string-36’, ‘uuid-hex-string-36-p’.

Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-byte-array-16-to-integer UUID-BA-16

Convert a UUID byte-array representaton to its decimal integer representaton. UUID-BA-16 is an object of type ‘uuid-byte-array-16’.
Return value is an integer with an upper-bounds of a ‘uuid-ub128’.

:EXAMPLE
(uuid-bit-vector-to-integer
(uuid-to-bit-vector
(make-v5-uuid *uuid-namespace-dns* "bubba")))
;=> 317192554773903544674993329975922389959

(uuid-integer-128-to-byte-array 317192554773903544674993329975922389959) ;=> #(238 161 16 94 54 129 81 23 153 182 123 43 95 225 243 199)

(uuid-byte-array-16-to-integer
(uuid-integer-128-to-byte-array 317192554773903544674993329975922389959)) ;=> 317192554773903544674993329975922389959

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-byte-arrays.lisp (file)

Function: uuid-byte-array-16-zeroed ()

Return an array of type ‘uuid-byte-array-16’ with all elements zeroed.

:EXAMPLE

(uuid-byte-array-16-zeroed)

(typep (uuid-byte-array-16-zeroed) ’uuid-byte-array-16)

(uuid-byte-array-16-p (uuid-byte-array-16-zeroed))

:SEE-ALSO ‘uuid-bit-vector-128-zeroed’, ‘uuid-byte-array-16-p’, ‘uuid-byte-array-null-p’, ‘uuid-byte-array-null’.

Package

unicly

Source

unicly-byte-arrays.lisp (file)

Function: uuid-byte-array-null-p BYTE-ARRAY-MAYBE-NULL

Whether object is of type ‘unicly:uuid-byte-array-null’.

:EXAMPLE

(uuid-byte-array-null-p (uuid-byte-array-16-zeroed))

(uuid-byte-array-null-p (make-array 16 :element-type ’uuid-ub8 :initial-element 0))

(not (uuid-byte-array-null-p (make-array 16 :element-type ’uuid-ub8 :initial-element 1)))

(not (uuid-byte-array-null-p (uuid-bit-vector-128-zeroed)))

:SEE-ALSO ‘uuid-byte-array-16-zeroed’, ‘uuid-byte-array-16-p’.

Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-byte-array-to-bit-vector UUID-BYTE-ARRAY
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-byte-string-p MAYBE-OBJECT-OF-TYPE

Whether object is of type ‘uuid-byte-string’.

Return T when object has the type signature:

(simple-array character (16))

:EXAMPLE

(uuid-byte-string-p (uuid-get-bytes (uuid-print-bytes nil *uuid-namespace-dns*)))

:SEE-ALSO ‘uuid-hex-string-36-p’, ‘uuid-byte-array-16-p’.

Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-copy-uuid UUID-INSTANCE

Copy slot-value’s of UUID-INSTANCE to new instance and return new instance.

UUID-INSTANCE should satisfy ‘unique-universal-identifier-p’, an error is signaled if not.

:EXAMPLE

(let* ((source *uuid-namespace-dns*)
(clone (uuid-copy-uuid source)))
(not (or (eq clone source)
(eql clone source)
(equal clone source)
(equalp clone source))))

:NOTE The base slot-values of an instance of ‘unique-universal-identifier’ class are constants and satisfy ‘cl:constantp’:

(constantp (slot-value *uuid-namespace-dns* ’%uuid_time-low))

Therefor, the newly returned copy will not share mutable structure with
its source UUID-INSTANCE.

:NOTE Because there should only ever be one true instance of the null-uuid when UUID-INSTANCE satisfies ‘unique-universal-identifier-null-p’ the returned copy of UUID-INSTANCE is an instance of class ‘unique-universal-identifier’ not an instance of class ‘unique-universal-identifier-null’ and the returned copy does not satisfy ‘unique-universal-identifier-null-p’. For example:

(unique-universal-identifier-null-p (make-null-uuid))

(unique-universal-identifier-null-p (uuid-copy-uuid (make-null-uuid)))

(type-of (uuid-copy-uuid (make-null-uuid)))

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-class.lisp (file)

Function: uuid-from-bit-vector BIT-VECTOR-128
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-from-byte-array BYTE-ARRAY

Convert BYTE-ARRAY to a UUID.

Return value is an instance of the UNIQUE-UNIVERSAL-IDENTIFIER class.

BYTE-ARRAY is a byte-array as returned by ‘uuid-to-byte-array’ it should be of
type ‘uuid-to-byte-array’ and satisfy the predicate
‘uuid-to-byte-array-p’:

:EXAMPLE

(uuid-from-byte-array (uuid-to-byte-array (make-uuid-from-string "6ba7b814-9dad-11d1-80b4-00c04fd430c8"))) :SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly.lisp (file)

Function: uuid-get-namespace-bytes UUID

Convert UUID to a byte-array.

Arg UUID should be an instance of the UNIQUE-UNIVERSAL-IDENTIFIER class.

Return value is an array of type ‘uuid-byte-array-16’ with the type signature:

(simple-array (unsigned-byte 8) (16))

It will satisfy the predicate ‘uuid-byte-array-16-p’.

:EXAMPLE

(uuid-get-namespace-bytes *uuid-namespace-dns*)

:SEE-ALSO ‘uuid-from-byte-array’.

Package

unicly

Source

unicly-byte-arrays.lisp (file)

Function: uuid-hex-string-32-p MAYBE-UUID-HEX-STRING-32

Whether object is of type ‘uuid-hex-string-32’.

Return T when object has the type signature:

(array character (32))

and satisfies ‘mon:string-all-hex-char-p’.

:EXAMPLE

(uuid-hex-string-32-p (uuid-print-bytes nil *uuid-namespace-dns*))

;; Following fails successfully:

(uuid-hex-string-32-p (print-object *uuid-namespace-dns* nil))

:SEE-ALSO ‘uuid-hex-string-36’, ‘uuid-hex-string-36-p’.

Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-hex-string-36-p MAYBE-UUID-HEX-STRING-36

Whether MAYBE-UUID-HEX-STRING-36 is a valid string representation of a UUID.

Return T when MAYBE-UUID-HEX-STRING-36 satisfies the following constraints:

- Its type is ’(array character 36)

- When split to list of strings on #\- delimter the list is of length is 5

- The length of each string in the list matches the pattern 8-4-4-4-12

- each string in the list satisfies ‘mon:string-all-hex-char-p’

:EXAMPLE

(uuid-hex-string-36-p "6ba7b810-9dad-11d1-80b4-00c04fd430c8")

(uuid-hex-string-36-p "6BA7B810-9DAD-11D1-80B4-00C04FD430C8")

;; Following fails successfully:

(uuid-hex-string-36-p "6BA7B810–9DAD-11D1-80B4-00C04FD430C8")

:SEE-ALSO ‘uuid-hex-string-32-p’, ‘uuid-hex-string-32’, ‘%uuid-hex-string-36-null-string-p’ ‘mon:split-string-on-chars’.

Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-string-32-p MAYBE-OBJECT-OF-TYPE

Whether object is of type ‘uuid-string-32’.

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-string-36-p MAYBE-OBJECT-OF-TYPE

Whether object is of type ‘uuid-string-36’.

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-to-bit-vector UUID
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-version-uuid UUID
Package

unicly

Source

unicly-uuid-version.lisp (file)


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

5.1.3 Generic functions

Generic Function: unique-universal-identifier-p OBJECT

Whether MAYBE-UUID-INSTANCE is a unique-universal-identifier.

Return T if argument is a class instance of ‘unique-universal-identifier’ or one of its subclasses.

:EXAMPLE

(unique-universal-identifier-p *uuid-namespace-dns*)

(unique-universal-identifier-p (uuid-to-bit-vector *uuid-namespace-dns*))

(unique-universal-identifier-p t)

:SEE-ALSO ‘uuid-eql’, ‘unicly::unique-universal-identifier-null-p’.

Package

unicly

Source

unicly-class.lisp (file)

Methods
Method: unique-universal-identifier-p (OBJECT unique-universal-identifier)
Method: unique-universal-identifier-p (OBJECT bit-vector)
Method: unique-universal-identifier-p OBJECT
Generic Function: uuid-eql UUID-A UUID-B

Whether object UUID-A is eql UUID-B.

:EXAMPLE

(uuid-eql (make-v5-uuid *uuid-namespace-dns* "bubba")
(make-v5-uuid *uuid-namespace-dns* "bubba"))

(uuid-eql (make-v5-uuid *uuid-namespace-dns* "bubba")
(make-v5-uuid *uuid-namespace-dns* "bubbA"))

(uuid-eql "bubb" "bobby")

(uuid-eql *uuid-null-uuid* *uuid-null-uuid*)

(uuid-eql *uuid-null-uuid* (make-null-uuid))

(uuid-eql (make-null-uuid) *uuid-null-uuid*)

(uuid-eql (make-null-uuid) (%make-null-uuid-loadtime))

(uuid-eql (make-null-uuid) (%make-null-uuid-loadtime))

(uuid-eql (make-null-uuid) (make-instance ’unique-universal-identifier-null))

(uuid-eql (make-instance ’unique-universal-identifier-null) (make-instance ’unique-universal-identifier-null))

(uuid-eql (make-instance ’unique-universal-identifier-null) (make-null-uuid))

(uuid-eql (make-instance ’unique-universal-identifier) (make-null-uuid))

:NOTE When either UUID-A or UUID-B is an instance of the class
‘unicly::unique-universal-identifier-null’ they are only considered to be
‘unicly:uuid-eql’ if both objects are ‘cl:eql’ the value of special variable
‘unicly::*uuid-null-uuid*’.

:SEE-ALSO ‘unique-universal-identifier-p’.

Package

unicly

Source

unicly-class.lisp (file)

Methods
Method: uuid-eql (UUID-A (eql nil)) (UUID-B (eql nil))
Method: uuid-eql (UUID-A (eql nil)) (UUID-B unique-universal-identifier-null)
Method: uuid-eql (UUID-A unique-universal-identifier-null) (UUID-B (eql nil))
Method: uuid-eql (UUID-A unique-universal-identifier-null) (UUID-B unique-universal-identifier-null)
Method: uuid-eql (UUID-A (eql nil)) (UUID-B unique-universal-identifier)
Method: uuid-eql (UUID-A unique-universal-identifier) (UUID-B (eql nil))
Method: uuid-eql (UUID-A unique-universal-identifier-null) (UUID-B unique-universal-identifier)
Method: uuid-eql (UUID-A unique-universal-identifier) (UUID-B unique-universal-identifier-null)
Method: uuid-eql UUID-A (UUID-B unique-universal-identifier-null)
Method: uuid-eql (UUID-A unique-universal-identifier-null) UUID-B
Method: uuid-eql (UUID-A unique-universal-identifier) (UUID-B unique-universal-identifier)
Method: uuid-eql (UUID-A bit-vector) (UUID-B bit-vector)
Method: uuid-eql (UUID-A bit-vector) (UUID-B unique-universal-identifier)
Method: uuid-eql (UUID-A unique-universal-identifier) (UUID-B bit-vector)
Method: uuid-eql (UUID-A unique-universal-identifier) UUID-B
Method: uuid-eql UUID-A (UUID-B unique-universal-identifier)
Method: uuid-eql UUID-A UUID-B
Generic Function: uuid-princ-to-string UUID &key

Return string representation of UUID-INSTANCE as if by ‘cl:princ-to-string’.

:SEE-ALSO ‘uuid-print-bytes-to-string’, ‘uuid-print-bytes’.

Package

unicly

Source

unicly-class.lisp (file)

Methods
Method: uuid-princ-to-string (UUID unique-universal-identifier) &key
Generic Function: uuid-print-bit-vector UUID &key STREAM

Print the bit-vector representation of UUID in a format suitable to its class to STREAM.

UUID an object representing an instance of ‘unique-universal-identifier’ class or subclass.

STREAM is an output-stream.

:SEE-ALSO ‘uuid-print-bytes-to-string’.

Package

unicly

Source

unicly-class.lisp (file)

Methods
Method: uuid-print-bit-vector (UUID unique-universal-identifier-null) &key STREAM

If UUID is ‘unique-universal-identifier-null-p’ print it’s bit-vector representation.

If not, an error is signaled.

:EXAMPLE

(uuid-print-bit-vector (make-null-uuid) nil)

;; Following fails successfully:

(uuid-print-bit-vector (make-instance ’unique-universal-identifier-null) nil)

(find-method (#’uuid-print-bit-vector) nil ’(unique-universal-identifier-null))

:NOTE Only the null-UUID created as if by ‘make-null-uuid’ may have its
uuid-bit-vector-128 representation printed with this method.
IOW, The results are unspecified if and attempt is made to to create null uuid objects as if by:

(make-instance ’unique-universal-identifier-null)

:SEE-ALSO ‘<XREF>’.

Method: uuid-print-bit-vector (UUID unique-universal-identifier) &key STREAM

Print the ‘uuid-bit-vector-128’ representation UUID to STREAM.

UUID is an instance of class ‘unique-universal-identifier’.

:EXAMPLE

(uuid-print-bit-vector (make-v4-uuid) nil)

(find-method #’uuid-print-bit-vector nil ’(t unique-universal-identifier))

:SEE-ALSO ‘uuid-princ-to-string’.

Method: uuid-print-bit-vector (UUID simple-bit-vector) &key STREAM

Print the bit-vector reprsentation of UUID to STREAM.

UUID should be an object of type ‘uuid-bit-vector-128’, an error is signaled if not.

:EXAMPLE

(uuid-print-bit-vector nil (uuid-bit-vector-128-zeroed))

(find-method #’uuid-print-bit-vector nil ’(t simple-bit-vector))

:SEE-ALSO ‘uuid-to-bit-vector’.

Generic Function: uuid-print-bytes-to-string UUID &key STRING-OR-CHAR-TYPE UPCASE

Print the bytes of UUID in a format suitable to its class to a string.

When keyword STRING-OR-CHAR-TYPE is non-nil specializing methods may provide opmitimizations around this arg.

:SEE-ALSO ‘uuid-print-bytes’.

Package

unicly

Source

unicly-class.lisp (file)

Methods
Method: uuid-print-bytes-to-string (UUID vector) &key STRING-OR-CHAR-TYPE UPCASE

Print the byte-array representation of UUID in a format suitable to its class to STREAM.

UUID is an object of type ‘uuid-byte-array-16’ representang of an instance of ‘unique-universal-identifier’ class or subclass.
Keyword STRING-OR-CHAR-TYPE is non-nil it is a string or the symbol ’base-char or ’character.

When it is ‘cl:stringp’ and satisfies ‘string-with-fill-pointer-p’ print the
UUID’s hexadecimal byte representation to STRING.

:EXAMPLE

(uuid-print-bytes-to-string
(uuid-to-byte-array (make-v5-uuid *uuid-namespace-dns* "bubba")))
;=> "eea1105e3681511799b67b2b5fe1f3c7"

(uuid-print-bytes-to-string
(uuid-to-byte-array (make-v5-uuid *uuid-namespace-dns* "bubba"))
:upcase t)
;=> "EEA1105E3681511799B67B2B5FE1F3C7"

(uuid-print-bytes-to-string
(uuid-to-byte-array (make-v5-uuid *uuid-namespace-dns* "bubba"))
:string-or-char-type (make-array 32 :element-type ’base-char :fill-pointer 0))
;=> "eea1105e3681511799b67b2b5fe1f3c7"

(uuid-print-bytes-to-string
(uuid-to-byte-array (make-v5-uuid *uuid-namespace-dns* "bubba"))
:string-or-char-type (make-array 32 :element-type ’character :fill-pointer 0))
;=> "eea1105e3681511799b67b2b5fe1f3c7"

(uuid-print-bytes-to-string
(uuid-to-byte-array (make-v5-uuid *uuid-namespace-dns* "bubba"))
:string-or-char-type (make-array 32 :element-type ’character :fill-pointer 0)
:upcase t)
;=> "EEA1105E3681511799B67B2B5FE1F3C7"

(type-of (uuid-print-bytes-to-string
(uuid-to-byte-array (make-v5-uuid *uuid-namespace-dns* "bubba")) :string-or-char-type (make-array 32 :element-type ’character :fill-pointer 0) :upcase t))
;=> (SIMPLE-ARRAY CHARACTER (32))

(type-of (uuid-print-bytes-to-string
(uuid-to-byte-array (make-v5-uuid *uuid-namespace-dns* "bubba")) :string-or-char-type (make-array 32 :element-type ’base-char :fill-pointer 0) :upcase t))
;=> (SIMPLE-BASE-STRING 32)

(type-of (uuid-print-bytes-to-string
(uuid-to-byte-array (make-v5-uuid *uuid-namespace-dns* "bubba")) :string-or-char-type (make-array 32 :element-type ’character :fill-pointer 0))) ;=> (AND (VECTOR CHARACTER 32) (NOT SIMPLE-ARRAY))

(type-of (uuid-print-bytes-to-string
(uuid-to-byte-array (make-v5-uuid *uuid-namespace-dns* "bubba")) :string-or-char-type (make-array 32 :element-type ’base-char :fill-pointer 0))) ;=> (AND (BASE-STRING 32) (NOT SIMPLE-ARRAY))

(type-of (uuid-print-bytes-to-string
(uuid-to-byte-array (make-v5-uuid *uuid-namespace-dns* "bubba"))))
;=> (AND (BASE-STRING 32) (NOT SIMPLE-ARRAY))

(type-of (uuid-print-bytes-to-string
(uuid-to-byte-array (make-v5-uuid *uuid-namespace-dns* "bubba")) :string-or-char-type ’character))
;=> (AND (VECTOR CHARACTER 32) (NOT SIMPLE-ARRAY))

(type-of (uuid-print-bytes-to-string
(uuid-to-byte-array (make-v5-uuid *uuid-namespace-dns* "bubba")) :string-or-char-type ’character
:upcase t))
;=> (SIMPLE-ARRAY CHARACTER (32))

(type-of (uuid-print-bytes-to-string
(uuid-to-byte-array (make-v5-uuid *uuid-namespace-dns* "bubba")) :string-or-char-type ’base-char
:upcase t))
;=> (SIMPLE-BASE-STRING 32)

:SEE-ALSO ‘<XREF>’.

Method: uuid-print-bytes-to-string (UUID unique-universal-identifier) &key STRING-OR-CHAR-TYPE UPCASE

Print bytes of UUID in hexadecimal representation to a ‘uuid-string-32’.

Keyword STRING-OR-CHAR-TYPE is non-nil it is a string or the symbol ’base-char or ’character.
When it is ‘cl:stringp’ and satisfies ‘string-with-fill-pointer-p’
print hexadecimal representation of bytes to STRING.
Default method speciaclized on instances of class ‘unique-universal-identifier’.
:EXAMPLE

(uuid-print-bytes-to-string (make-v4-uuid))

(uuid-print-bytes-to-string (make-v5-uuid *uuid-namespace-dns* "bubba") :upcase t)
(let ((fp-string (make-array 11
:element-type ’base-char
:fill-pointer 11
:initial-contents "UUID-BYTES:")))
(format fp-string "~%")
(uuid-print-bytes-to-string (make-v4-uuid) fp-string))

(type-of
(uuid-print-bytes-to-string (make-v5-uuid *uuid-namespace-dns* "bubba")
:string-or-char-type (make-array 32 :element-type ’base-char :fill-pointer 0) :upcase t))
;=> (SIMPLE-BASE-STRING 32)

(type-of
(uuid-print-bytes-to-string (make-v5-uuid *uuid-namespace-dns* "bubba")
:string-or-char-type (make-array 32 :element-type ’character :fill-pointer 0) :upcase t))
;=> (SIMPLE-ARRAY CHARACTER (32))

(type-of
(uuid-print-bytes-to-string (make-v5-uuid *uuid-namespace-dns* "bubba")
:string-or-char-type (make-array 32 :element-type ’character :fill-pointer 0))) ;=> (AND (VECTOR CHARACTER 32) (NOT SIMPLE-ARRAY))

(type-of
(uuid-print-bytes-to-string (make-v5-uuid *uuid-namespace-dns* "bubba")
:string-or-char-type (make-array 32 :element-type ’base-char :fill-pointer 0))) ;=> (AND (BASE-STRING 32) (NOT SIMPLE-ARRAY))

(type-of (uuid-print-bytes-to-string (make-v5-uuid *uuid-namespace-dns* "bubba")
:string-or-char-type ’character
:upcase t))
;=> (SIMPLE-ARRAY CHARACTER (32))

(type-of (uuid-print-bytes-to-string (make-v5-uuid *uuid-namespace-dns* "bubba")
:string-or-char-type ’base-char
:upcase t))
;=> (SIMPLE-BASE-STRING 32)

(type-of (uuid-print-bytes-to-string (make-v5-uuid *uuid-namespace-dns* "bubba")
:string-or-char-type ’character ))
;=> (AND (VECTOR CHARACTER 32) (NOT SIMPLE-ARRAY))

(type-of (uuid-print-bytes-to-string (make-v5-uuid *uuid-namespace-dns* "bubba")
:string-or-char-type ’base-char ))
;=> (AND (BASE-STRING 32) (NOT SIMPLE-ARRAY))

:NOTE Per RFC4122 Section 3. "Namespace Registration Template"
,—-
| The hexadecimal values "a" through "f" are output as
| lower case characters and are case insensitive on input.
‘—-

:SEE-ALSO ‘uuid-print-bytes’, ‘uuid-print-bit-vector’, ‘uuid-princ-to-string’.


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

5.1.4 Classes

Class: unique-universal-identifier ()

Representation of an UUID.

The string representation of A UUID has the format:


clock-seq-and-reserved
time-mid | clock-seq-low
| | | 6ba7b810-9dad-11d1-80b4-00c04fd430c8
| | |
‘ time-low | ‘ node
‘ time-high-and-version
Each field is treated as an integer and has its value printed as a zero-filled hexadecimal digit string with the most significant digit first.

0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| %uuid_time-low | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| %uuid_time-mid | %uuid_time-high-and-version | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|clk-seq-hi-res | clock-seq-low | %uuid_node (0-1) | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| %uuid_node (2-5) | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

Following table enumates the slot/type/value correspondence for instances of this class:

SLOT TYPE BYTE-ARRAY SIZE ‘%uuid_time-low’ ‘uuid-ub32’ #(<BYTE> <BYTE> <BYTE> <BYTE>), 4 ‘%uuid_time-mid’ ‘uuid-ub16’ #(<BYTE> <BYTE>), 2 ‘%uuid_time-high-and-version’ ‘uuid-ub16’ #(<BYTE> <BYTE>), 2 ‘%uuid_clock-seq-and-reserved’ ‘uuid-ub8’ #(<BYTE>), 1
‘%uuid_clock-seq-low’ ‘uuid-ub8’ #(<BYTE>), 1
‘%uuid_node’ ‘uuid-ub48’ #(<BYTE> <BYTE> <BYTE> <BYTE> <BYTE> <BYTE>), 6

While RFC4122 specifically indicates that certain bits of a UUID shall not be
set and/or are reserved for future use, were the full range of its 128 bit
integer representation used it could have an upper bounds with the decimal representation: 340282366920938463463374607431768211455 e.g.:

(integer-length 340282366920938463463374607431768211455)
=> 128

In long-form this number is:

340,282,366,920,938,463,463,374,607,431,768,211,455 340 undecillion, 282
decillion, 366 nonillion, 920 octillion, 938 septillion, 463 sextillion, 463 quintillion, 374 quadrillion, 607 trillion, 431 billion, 768 million, 211
thousand and 455

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-class.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

unique-universal-identifier-null (class)

Direct methods
Direct slots
Slot: %uuid_time-low

An integer of type ‘uuid-ub32’.

The low field of a UUID record’s timestamp.
Referenced as the ‘time_low‘ field in RFC4122.

Occurs in a UUID ‘uuid-byte-array-16’ representation as a 4 octet value at
offset 0 through index 3.

A digested UUID’s byte-array octets are accessible with ‘%uuid_time-low-request’.

Occurs in a UUID ‘uuid-bit-vector-128’ representation from offset 0 through index 31.

Occurs as the 0 element in a UUID string delimited by #\-.

Its string representation is 8 hexadecimal characters.

Type

unicly::uuid-ub32

Initargs

:%uuid_time-low

Initform

0

Slot: %uuid_time-mid

An integer of type ‘uuid-ub16’.

The middle field of a UUID record’s timestamp.
Referenced as the ‘time_mid‘ field in RFC4122.

Occurs in a UUID ‘uuid-byte-array-16’ representation as a 2 octet value at offset 4 through index 5.

A digested UUID’s byte-array octets are accessible with ‘%uuid_time-mid-request’.

Occurs in a UUID ‘uuid-bit-vector-128’ representation from offset 32 through index 47.

Occurs as the 1 element in a UUID string delimited by #\-.

Its string representation is 4 hexadecimal characters.

Type

unicly::uuid-ub16

Initargs

:%uuid_time-mid

Initform

0

Slot: %uuid_time-high-and-version

An integer of type ‘uuid-ub16’.

The high field of a UUID record’s bit integer timestamp multiplexed with its version. Referenced as the ‘time_high_and_version‘ field in RFC4122.

Occurs in a UUID ‘uuid-byte-array-16’ representation as a 2 octet value at offset
6 through index 7.

A digested UUID’s byte-array octets are accessible with ‘%uuid_time-high-and-version-request’.

Occurs in a UUID ‘uuid-bit-vector-128’ representation from offset 48 through index 63. :NOTE Per RFC4122 Section 4.1.3, bit 48 should always be 0.

Occurs as the 2 element in a UUID string delimited by #\-.

Its string representation is 4 hexadecimal characters.

Type

unicly::uuid-ub16

Initargs

:%uuid_time-high-and-version

Initform

0

Slot: %uuid_clock-seq-and-reserved

An integer of type ‘uuid-ub8’.

The high field of a UUID record’s bit integer clock sequence multiplexed with its variant. Referenced as the ‘clock_seq_hi_and_reserved‘ field of RFC4122.

Occurs in a UUID uuid-byte-array-16 representation as an octet value at offset 8.

Occurs in a UUID ‘uuid-bit-vector-128’ representation from offset 64 through index 71.

A digested UUIDs byte-array octets are accessible with ‘%uuid_clock-seq-and-reserved-request’.

Occurs in the upper portion of the 3 element in a UUID string delimited by #\-.

Its string representation is 2 hexadecimal characters.

:NOTE As referenced in RFC4122 Section 4.1.1, the bits of this integer carry the
UUID’s variant layout/type with the top 3 most significant bits formatted as follows:

Msb0 Msb1 Msb2
1 0 x ; where X indicates a "don’t care" value

:NOTE UUID v3, v4, v5 instances of this class will have the relevenat portions
of their bit fields returned in the above configuration.

Type

unicly::uuid-ub8

Initargs

:%uuid_clock-seq-and-reserved

Initform

0

Slot: %uuid_clock-seq-low

An integer of type ‘uuid-ub8’.

The low field of the UUID record’s bit integer clock sequence.
Referenced as the ‘clock_seq_low‘ field of RFC4122.

Occurs in a UUID ‘uuid-byte-array-16’ representation as an octet value at offset 9.

A digested UUIDs byte-array octets are accessible with ‘%uuid_clock-seq-low-request’.

Occurs in a UUID ‘uuid-bit-vector-128’ representation from offset 72 through index 79.

Occurs in the lower portion of the 3 element in a UUID string delimited by #\-.

Its string representation is 2 hexadecimal characters.

Type

unicly::uuid-ub8

Initargs

:%uuid_clock-seq-low

Initform

0

Slot: %uuid_node

An integer of type ‘uuid-ub48’.

The "spatially unique" identifier portion of a UUID record’s bit integer.
Referenced as the ‘node‘ field of RFC4122.

Occurs in a UUID uuid-byte-array-16 representation as a 6 octet value at offset 10 through index 15. A digested UUID’s byte-array octets are accessible with ‘%uuid_node-request’.
:NOTE a digest v5 UUID is initally an object of type ‘uuid-byte-array-20’ with offest 16-19 truncated.

Occurs in a UUID ‘uuid-bit-vector-128’ representation from offset 79 through 127.

Occurs as the final or 4 element in a UUID string delimited by #\-.

Its string representation is 12 hexadecimal characters.

Type

unicly::uuid-ub48

Initargs

:%uuid_node

Initform

0


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

5.2 Internal definitions


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

5.2.1 Constants

Constant: +%%uuid-sxhash-truncating-node%%+
Package

unicly

Source

unicly-hash-table.lisp (file)

Constant: +uuid-null-string+
Package

unicly

Source

unicly-specials.lisp (file)


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

5.2.2 Special variables

Special Variable: *author-maintainer-contact*
Package

unicly-asd

Source

unicly.asd

Special Variable: *hexadecimal-chars*
Package

unicly

Source

unicly-utils.lisp (file)

Special Variable: *random-state-uuid*

A random-state objet for use when generating UUIDv4 UUIDs.

:EXAMPLE

*random-state-uuid*

(random-state-p *random-state-uuid*)

:SEE-ALSO ‘cl:random-state’, ‘cl:random-state-p’.

Package

unicly

Source

unicly-specials.lisp (file)

Special Variable: *uuid-allow-empty-string-name-args*

When value is null ‘make-v3-uuid’ and ‘make-v5-uuid’ will error when their NAME argumement is not of type ‘unicly::string-not-empty’.

:SEE-ALSO ‘*uuid-allow-null-like-namespace-args*’, ‘unicly::verify-sane-namespace-and-name’, ‘unicly::%verify-non-empty-name-arg’, ‘unicly::%verify-non-null-namespace-arg’.

Package

unicly

Source

unicly-specials.lisp (file)

Special Variable: *uuid-allow-null-like-namespace-args*

When value is null, ‘make-v3-uuid’ and ‘make-v5-uuid’ will error when their
NAMESPACE argumement is an instance of the class ‘unique-universal-identifier’
with all of its slot-values satisfying ‘cl:zerop’ but which doesn’t satisfy ‘unique-universal-identifier-null-p’.

:NOTE RFC 4122 probably didn’t have CLOS in mind w/r/t the null-uuid and as
such when either of the following type of object is allowed as a NAMESPACE
argument it may produce unexpected results and with unexpected consequences
which may not be easily detected after the fact:

(unique-universal-identifier-null-p (make-instance ’unique-universal-identifier)) (unique-universal-identifier-null-p (make-instance ’unique-universal-identifier-null)) (unique-universal-identifier-null-p (make-instance ’mop-frobbed-subclass-of-unique-universal-identifier)) Their may be a performance impact when this argument is nil (the default) b/c we
will have to check the slot-values of each namespace arg for each evaluation
of ‘make-v5-uuid’ / ‘make-v3-uuid’.

A reasonable way to avoid this impact is to cache the NAMESPACEs common to a
class you control and dynamically bind this variable inside a wrapper function:

(make-v5-uuid-with-cached-namespace (name)
(let ((*uuid-allow-null-like-namespace-args* t))
(make-v5-uuid <CACHED-NAMESPACE> name)))

:SEE-ALSO ‘*uuid-allow-empty-string-name-args*’, ‘unicly::verify-sane-namespace-and-name’, ‘unicly::%verify-non-empty-name-arg’,
‘unicly::%verify-non-null-namespace-arg’.

Package

unicly

Source

unicly-specials.lisp (file)

Special Variable: *uuid-null-uuid*

The default null-uuid per RFC4122 Section 4.1.7 "Nil UUID".

The value of this variable is initialized at loadtime with ‘unicly::%make-null-uuid-loadtime’.

User code should not neither direclty access nor set the value of this
variable and should instead always use ‘unicly:make-null-uuid’!

It is an an object of type ‘unicly::unique-universal-identifier-null’.

The value of this variable should always evalute to the same object as there
are methods specialized it, e.g.:

(uuid-eql *uuid-null-uuid* *uuid-null-uuid*)

(uuid-eql *uuid-null-uuid* (make-null-uuid))

(uuid-eql (make-null-uuid) *uuid-null-uuid*)

(uuid-eql *uuid-null-uuid* (make-instance ’unicly::unique-universal-identifier-null))

(uuid-eql *uuid-null-uuid* (make-instance ’unicly::unique-universal-identifier))

:NOTE The value of this variable should always return t for the following:

(and (slot-exists-p *uuid-null-uuid* ’%uuid_null)
(slot-value *uuid-null-uuid* ’%uuid_null))

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-specials.lisp (file)


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

5.2.3 Macros

Macro: def-indexed-hexstring-integer-parser FUN-NAME VEC-INDEX STRING-TYPE-AT-INDEX STRING-START STRING-END STRING-INTEGER-TYPE

Convenience macro for defining functions which ‘cl:parse-integer’ of the
simple-array character elements returnd as nth-value 1 as an object of type ‘uuid-simple-vector-5’ by ‘uuid-hex-string-36-p’

FUN-NAME is a string used when generating a function-name to intern in the UNICLY package. String should not be preceded/trailed by #\- or whitespace.

Arg VEC-INDEX is an integer value of type (mod 5) indicating an index into the
return value of ‘uuid-hex-string-36-p’.

Arg STRING-TYPE-AT-INDEX is an unqouted symol naming a subtype of ‘uuid-hex-string-length’. Valid types are:

‘uuid-hex-string-8’ ‘uuid-hex-string-4’ ‘uuid-hex-string-12’

Arg STRING-START is a postivie integer indicating the lower bounds of the
hex-string located at VEC-INDEX.

Arg STRING-END is a postivie integer value indicating an upper bounds of the hex-string located at VEC-INDEX.

STRING-INTEGER-TYPE Is an unquoted symbol naming an uuid unsigned-byte type to
declare for the value returned by ‘cl:parse-integer’ of the string at
VEC-INDEX. Valid types are:

‘uuid-ub32’ ‘uuid-ub16’ ‘uuid-ub8’ ‘uuid-ub48’

Expands to a function defining form with the following format:

(defun <FUN-NAME> (hex-vector-5)
(declare (uuid-simple-vector-5 hex-vector-5)
(optimize (speed 3)))
(uuid-string-parse-integer
(uuid-svref-for-parse-integer HEX-VECTOR-5 <VEC-INDEX> <STRING-TYPE-AT-INDEX>) <STRING-START> <STRING-END> <STRING-INTEGER-TYPE> ))

:EXAMPLE

(macroexpand-1 ’(def-indexed-hexstring-integer-parser
"time-low"
0
uuid-hex-string-8
0 8 uuid-ub32))

:SEE-ALSO ‘uuid-hex-vector-parse-time-low’, ‘uuid-hex-vector-parse-time-mid’, ‘uuid-hex-vector-parse-time-high-and-version’, ‘uuid-hex-vector-parse-clock-seq-and-reserved’,
‘uuid-hex-vector-parse-clock-seq-low’, ‘uuid-hex-vector-parse-node’.

Package

unicly

Source

unicly-macros.lisp (file)

Macro: def-make-uuid-byte-array-extended MAKE-EXTENDED-SUFFIX EXTENDED-CLASS &optional NO-VERIFY
Package

unicly

Source

unicly-extend.lisp (file)

Macro: def-make-uuid-extend-class-fun MAKE-EXTENDED-SUFFIX EXTENDED-CLASS

Define functions which provide a the equivalent of the Unicly uuid API for subclasses of the class ‘unicly:unique-universal-identifier’.

MAKE-EXTENDED-SUFFIX is a non-quoted symbol which is appended to the symbol-name of each defined function.

EXTENDED-CLASS is a non-quoted which designates a valid subclass of the class ‘unicly:unique-universal-identifier’.

Following table outlines the correspondence of extended functions defined with their standard Unicly counterparts:

Extended Unicly API function Standard Unicly API function

make-v3-uuid-<FOO> ‘make-v3-uuid’
make-v4-uuid-<FOO> ‘make-v4-uuid’
make-v5-uuid-<FOO> ‘make-v5-uuid’ make-uuid-from-string-<FOO> ‘make-uuid-from-string’ make-uuid-from-byte-array-<FOO> ‘uuid-from-byte-array’ make-uuid-from-bit-vector-<FOO> ‘uuid-from-bit-vector’

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-extend.lisp (file)

Macro: def-make-uuid-from-string-extended MAKE-EXTENDED-SUFFIX EXTENDED-CLASS &optional NO-VERIFY
Package

unicly

Source

unicly-extend.lisp (file)

Macro: def-make-v3-uuid-extended MAKE-V3-UUID-SUFFIX V3-UUID-CLASS &optional NO-VERIFY
Package

unicly

Source

unicly-extend.lisp (file)

Macro: def-make-v4-uuid-extended MAKE-V4-UUID-SUFFIX V4-UUID-CLASS &optional NO-VERIFY
Package

unicly

Source

unicly-extend.lisp (file)

Macro: def-make-v5-uuid-extended MAKE-V5-UUID-SUFFIX V5-UUID-CLASS &optional NO-VERIFY
Package

unicly

Source

unicly-extend.lisp (file)

Macro: def-uuid-bit-vector-length-type BV-LENGTH

Convenience macro for defining subtypes of type ‘uuid-bit-vector-length’.

Arg BV-LENGTH is an positive integer value indicating the length of a uuid-bit-vector.

:EXAMPLE

(macroexpand-1 ’(def-uuid-bit-vector-length-type 16))

:SEE-ALSO ‘def-uuid-type-definer’, ‘def-uuid-unsigned-byte-size’, ‘def-uuid-bit-vector-N-type’, ‘def-uuid-bit-vector-length-type’, ‘def-uuid-unsigned-byte-integer-length’,
‘def-uuid-uuid-hex-string-length’, ‘def-uuid-byte-array-length’.

Package

unicly

Source

unicly-macros.lisp (file)

Macro: def-uuid-bit-vector-n-type BV-LENGTH-TYPE

Convenience macro for defining subtypes of type ‘uuid-bit-vector’.

Arg BV-LENGTH-TYPE is an positive integer value indicating the number of bits in a uuid-bit-vector.

:EXAMPLE

(macroexpand-1 ’(def-uuid-bit-vector-N-type 16))

:SEE-ALSO ‘def-uuid-type-definer’, ‘def-uuid-unsigned-byte-size’,
‘def-uuid-bit-vector-N-type’, ‘def-uuid-bit-vector-length-type’, ‘def-uuid-unsigned-byte-integer-length’,
‘def-uuid-uuid-hex-string-length’, ‘def-uuid-byte-array-length’.

Package

unicly

Source

unicly-macros.lisp (file)

Macro: def-uuid-bit-vector-zeroed ZEROED-SIZE
Package

unicly

Source

unicly-macros.lisp (file)

Macro: def-uuid-byte-array-length BYTE-ARRAY-LENGTH

Convenience macro for defining subtypes of type ‘uuid-byte-array’.

BYTE-ARRAY-LENGTH is a positive integer indication the length of a simple-array with elements of type ‘uuid-ub8’. :EXAMPLE

(macroexpand-1 ’(def-uuid-byte-array-length 16))

:SEE-ALSO ‘def-uuid-type-definer’, ‘def-uuid-unsigned-byte-size’,
‘def-uuid-bit-vector-N-type’, ‘def-uuid-bit-vector-length-type’,
‘def-uuid-unsigned-byte-integer-length’,
‘def-uuid-uuid-hex-string-length’, ‘def-uuid-byte-array-length’.

Package

unicly

Source

unicly-macros.lisp (file)

Macro: def-uuid-from-bit-vector-extendable MAKE-UUID-FROM-BV-SUFFIX UUID-BV-CLASS &optional NO-VERIFY
Package

unicly

Source

unicly-extend.lisp (file)

Macro: def-uuid-predicate-and-type-check-definer TYPE-FOR-PRED-AND-CHECK

Convenience macro for defining predicate and check-type functions for Unicly types.

TYPE-FOR-PRED-AND-CHECK is a token designating an existing type-specifier.
Its symbol-name is used to generate two symbol-names to use as function names when defining a the predicate and check-type functions.
Generated predicate name has the form:

<TYPE-FOR-PRED-AND-CHECK>-P
Generated check-type name has the form:
<TYPE-FOR-PRED-AND-CHECK>-CHECK-TYPE
So given the type specifier UUID-BIT-VECTOR-8
the following two functions would be definened:
uuid-bit-vector-8-p uuid-bit-vector-8-check-type
In the case, uuid-bit-vector-8-check-type is defined with a body which checks if
some value satisfies uuid-bit-vector-8-p and if not signals a condition of type ‘uuid-simple-type-error’ its body having the format:

(unless (uuid-bit-vector-8-p <SOME-VALUE>)
(uuid-simple-type-error :datum <SOME-VALUE>
:expected-type uuid-bit-vector-8))

:EXAMPLE

(macroexpand-1 ’(def-uuid-predicate-and-type-check-definer uuid-bit-vector-32)) (macroexpand-all ’(def-uuid-predicate-and-type-check-definer uuid-bit-vector-32))

:NOTE The body of this macro expands into two addtional macros:

‘unicly::def-uuid-type-predicate-definer’
‘unicly::def-uuid-type-check-definer’

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-macros.lisp (file)

Macro: def-uuid-request-integer-bit-vector DEF-NAME BIT-OFFSET BIT-WIDTH

Convenience macro for functions which extract slot values of class ‘unique-universal-identifier’.

:EXAMPLE

(macroexpand-1 ’(def-uuid-request-integer-bit-vector "time-low" 0 32))

(macroexpand-1 ’(def-uuid-request-integer-bit-vector "time-mid" 32 16))

(macroexpand-1 ’(def-uuid-request-integer-bit-vector "time-high-and-version" 48 16))

(macroexpand-1 ’(def-uuid-request-integer-bit-vector "clock-seq-and-reserved" 64 8))

(macroexpand-1 ’(def-uuid-request-integer-bit-vector "clock-seq-low" 72 8))

(macroexpand-1 ’(def-uuid-request-integer-bit-vector "node" 80 48))

:SEE-ALSO
‘%uuid_time-low-request-bit-vector’, ‘%uuid_time-mid-request-bit-vector’, ‘%uuid_time-high-and-version-request-bit-vector’, ‘%uuid_clock-seq-and-reserved-request-bit-vector’,
‘%uuid_clock-seq-low-request-bit-vector’, ‘%uuid_node-request-bit-vector’.

Package

unicly

Source

unicly-macros.lisp (file)

Macro: def-uuid-type-check-definer TYPE-CHECK-NAME NAME-PREDICATE CHECKED-TYPE
Package

unicly

Source

unicly-macros.lisp (file)

Macro: def-uuid-type-definer PARENT-TYPE FORMAT-STRING LENGTH-ARG

Convenience macro for use by macros which define uuid sub-type specifiers.

Arg PARENT-TYPE is an unquoted symbol naming a uuid-type specifer which
accepts a positive integer value as an argument.

FORMAT-STRING is a format-string used to generate the symbol-name of the type to be defined. The types defined with by expanders of this macro have an integer value as
part of theier symbol name, as such format-string should contain the
format-control flag "~D" in an appropriate position.

LENGTH-ARG an positive integer value. It is used as the format-argument to
FORMAT-STRING and as the argument to its PARENT-TYPE.

:EXAMPLE

(macroexpand-1 ’(def-uuid-type-definer uuid-bit-vector "UUID-BIT-VECTOR-~D" 128))

:SEE-ALSO ‘def-uuid-type-definer’, ‘def-uuid-unsigned-byte-size’, ‘def-uuid-bit-vector-N-type’, ‘def-uuid-bit-vector-length-type’, ‘def-uuid-unsigned-byte-integer-length’,
‘def-uuid-uuid-hex-string-length’, ‘def-uuid-byte-array-length’.

Package

unicly

Source

unicly-macros.lisp (file)

Macro: def-uuid-type-predicate-definer PREDICATE-NAME TYPE-TO-CHECK
Package

unicly

Source

unicly-macros.lisp (file)

Macro: def-uuid-unsigned-byte-integer-length UNSIGNED-LENGTH

Convenience macro for defining subtypes of type ‘uuid-unsigned-byte-integer-length’.

Arg UNSIGNED-LENGTH is an positive integer value indicating the
integer-length of the integer represetned at the upper-bounds of an unsigned-byte.

:EXAMPLE

(macroexpand-1 ’(def-uuid-unsigned-byte-integer-length 16))

:SEE-ALSO ‘def-uuid-type-definer’, ‘def-uuid-unsigned-byte-size’, ‘def-uuid-bit-vector-N-type’, ‘def-uuid-bit-vector-length-type’, ‘def-uuid-unsigned-byte-integer-length’,
‘def-uuid-uuid-hex-string-length’.

Package

unicly

Source

unicly-macros.lisp (file)

Macro: def-uuid-unsigned-byte-size SIZE-BYTES

Convenience macro for defining subtypes of type ‘uuid-unsigned-byte-size’.

Arg SIZE-BYTES is an positive integer value indicating the size of an unsigned-byte.

:EXAMPLE

(macroexpand-1 ’(def-uuid-unsigned-byte-size 128))

:SEE-ALSO ‘def-uuid-type-definer’, ‘def-uuid-unsigned-byte-size’, ‘def-uuid-bit-vector-N-type’, ‘def-uuid-bit-vector-length-type’, ‘def-uuid-unsigned-byte-integer-length’,
‘def-uuid-uuid-hex-string-length’, ‘def-uuid-byte-array-length’.

Package

unicly

Source

unicly-macros.lisp (file)

Macro: def-uuid-uuid-hex-string-length HEX-STRING-LENGTH

Convenience macro for defining subtypes of type ‘uuid-hex-string-length’.

Arg HEX-STRING-LENGTH is an positive integer value indicating the length of a simple-array of characters.

:EXAMPLE

(macroexpand-1 ’(def-uuid-uuid-hex-string-length 12))

:SEE-ALSO ‘def-uuid-type-definer’, ‘def-uuid-unsigned-byte-size’,
‘def-uuid-bit-vector-N-type’, ‘def-uuid-bit-vector-length-type’, ‘def-uuid-unsigned-byte-integer-length’,
‘def-uuid-uuid-hex-string-length’.

Package

unicly

Source

unicly-macros.lisp (file)

Macro: defconst NAME VALUE &optional DOC
Package

unicly

Source

unicly-specials.lisp (file)

Macro: uuid-string-parse-integer UUID-HEX-STRING START END INTEGER-TYPE

Helper macro for ‘make-uuid-from-string’ to ‘cl:parse-integer’ a hex-string.

Wraps macro ‘uuid-svref-for-parse-integer’.

Wrapped by macro ‘def-indexed-hexstring-integer-parser’.

Arg UUID-HEX-STRING is a ‘uuid-hex-string-36’ or a subtype.

Arg START is a lower bounds indexing into UUID-HEX-STRING.

Arg END is an upper bounds indexing into UUID-HEX-STRING.

INTEGER-TYPE is an unquoted symbol naming the type of uuid-unsigned-byte-size to
declare for the value returned by ‘cl:parse-integer’ of the hex-string at at
index bounded by START and END Valid types are:

‘uuid-ub32’ ‘uuid-ub16’ ‘uuid-ub8’ ‘uuid-ub48’

:EXAMPLE

(macroexpand-1 ’(uuid-string-parse-integer "6ba7b810-9dad-11d1-80b4-00c04fd430c8" 0 8 uuid-ub32))

(let ((uuid-str "6ba7b810-9dad-11d1-80b4-00c04fd430c8")
(parse-specs ’((0 8 uuid-ub32)
(9 13 uuid-ub16)
(14 18 uuid-ub16)
(19 21 uuid-ub8)
(21 23 uuid-ub8)
(24 36 uuid-ub48)))
(gthr ’()))
(dolist (m parse-specs (setf gthr (nreverse gthr)))
(push (apply #’uuid-string-parse-integer m) gthr)))

:SEE-ALSO ‘make-uuid-from-string-if’.

Package

unicly

Source

unicly-macros.lisp (file)

Macro: uuid-svref-for-parse-integer SIMPLE-VECTOR-5 INDEX STRING-TYPE

Convenience macro for declared references to STRING-TYPEs at INDEX of SIMPLE-VECTOR-5.

Wrapped by macros ‘def-indexed-hexstring-integer-parser’ and ‘uuid-string-parse-integer’.

SIMPLE-VECTOR-5 is an object of type ‘uuid-simple-vector-5’ as returned as the ‘cl:nth-value’ 1 of ‘uuid-hex-string-36-p’.

STRING-TYPE is a subtype of ‘uuid-hex-string-length’

Arg STRING-TYPE is an unqouted symol naming the type of string at INDEX. It
should be a subtype of ‘uuid-hex-string-length’. Valid types are:

‘uuid-hex-string-8’ ‘uuid-hex-string-4’ ‘uuid-hex-string-12’

:EXAMPLE

(macroexpand-1 ’(uuid-svref-for-parse-integer
(nth-value 1 (uuid-hex-string-36-p (uuid-princ-to-string (make-v4-uuid)))) 4 uuid-hex-string-12))

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-macros.lisp (file)


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

5.2.4 Compiler macros

Compiler Macro: uuid-request-integer ARRAY OFFSET LENGTH &key LITTLE-ENDIAN SIGN-EXTEND
Package

unicly

Source

unicly-integers.lisp (file)


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

5.2.5 Functions

Function: %def-uuid-format-and-intern-symbol FORMAT-STRING FORMAT-ARG
Package

unicly

Source

unicly-macros.lisp (file)

Function: %def-uuid-format-and-intern-symbol-type-checker TYPE-SYMBOL-OR-STRING
Package

unicly

Source

unicly-macros.lisp (file)

Function: %def-uuid-format-and-intern-symbol-type-predicate TYPE-SYMBOL-OR-STRING
Package

unicly

Source

unicly-macros.lisp (file)

Function: %lw-string-zerop STRING
Package

unicly

Source

unicly-utils.lisp (file)

Function: %make-null-uuid-loadtime ()
Package

unicly

Source

unicly-class.lisp (file)

Function: %make-uuid-from-bit-vector-extendable-bv-zeroed-error MAYBE-VALID-UUID-BIT-VECTOR

Return MAYBE-VALID-UUID-BIT-VECTOR or error if it is ‘unicly::uuid-bit-vector-null-p’.

:EXAMPLE

(let ((zero-bits (uuid-bit-vector-128-zeroed)))
(setf (sbit zero-bits 0) 1)
(%make-uuid-from-bit-vector-extendable-bv-zeroed-error zero-bits))

Following each fail succesfully:

(%make-uuid-from-bit-vector-extendable-bv-zeroed-error (make-array 129 :element-type ’bit :initial-element 1))

(%make-uuid-from-bit-vector-extendable-bv-zeroed-error (make-array 129 :element-type ’bit :initial-element 1))

(%make-uuid-from-bit-vector-extendable-bv-zeroed-error (make-array 16 :element-type ’bit))

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-extend.lisp (file)

Function: %make-uuid-from-byte-array-extended-null-array-error MAYBE-VALID-UUID-BYTE-ARRAY

Return MAYBE-VALID-UUID-BYTE-ARRAY if it is of type of type
‘unicly:uuid-byte-array-16’ without without all octets ‘cl:zerop’, if not an
error is signaled.

:EXAMPLE

(%make-uuid-from-byte-array-extended-null-array-error (uuid-to-byte-array (make-v4-uuid)))

(%make-uuid-from-byte-array-extended-null-array-error (uuid-byte-array-16-zeroed))

(null
(ignore-errors
(%make-uuid-from-byte-array-extended-null-array-error
(make-array 3 :element-type ’uuid-ub8 :initial-contents #(255 255 255)))))

(null (ignore-errors (%make-uuid-from-byte-array-extended-null-array-error (uuid-byte-array-16-zeroed))))

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-extend.lisp (file)

Function: %make-uuid-from-string-extended-null-string-error MAYBE-VALID-UUID-HEX-STRING-36

Return MAYBE-VALID-UUID-HEX-STRING-36 if it is not ‘cl:string=’ the constant ‘unicly::+uuid-null-string+’.

MAYBE-VALID-UUID-HEX-STRING-36 is a string of type ‘unicly::uuid-string-36’.

:EXAMPLE

(%make-uuid-from-string-extended-null-string-error "eea1105e-3681-5117-99b6-7b2b5fe1f3c7")

(%make-uuid-from-string-extended-null-string-error "not-a-valid-uuid-string-36")

(null (ignore-errors (%make-uuid-from-string-extended-null-string-error "00000000-0000-0000-0000-000000000000")))

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-extend.lisp (file)

Function: %string-not-empty-p MAYBE-NOT-NULL-OR-EMPTY-STRING
Package

unicly

Source

unicly-utils.lisp (file)

Function: %unique-universal-identifier-null-p OBJECT
Package

unicly

Source

unicly-class.lisp (file)

Function: %uuid-bit-vector-null-p BIT-VECTOR-MAYBE-NULL
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: %uuid-byte-array-null-p BYTE-ARRAY-MAYBE-NULL
Package

unicly

Source

unicly-types.lisp (file)

Function: %uuid-digest-uuid-instance-md5 NAMESPACE NAME
Package

unicly

Source

unicly.lisp (file)

Function: %uuid-digest-uuid-instance-sha1 NAMESPACE NAME
Package

unicly

Source

unicly.lisp (file)

Function: %uuid-hex-string-36-null-string-p SPLIT-VEC

Whether MAYBE-ALL-ZERO-OR-DASH-STRING-36 is of type ‘uuid-hex-string-36’ every character is ‘cl:char=’ either #\0 or #\-.

:EXAMPLE

(%uuid-hex-string-36-null-string-p "00000000-0000-0000-0000-000000000000")

(%uuid-hex-string-36-null-string-p "00000000-0000-0000-0000-000000000001")

:SEE-ALSO ‘uuid-hex-string-36-p’.

Package

unicly

Source

unicly-types.lisp (file)

Function: %uuid-octets-to-string CONVERT-BYTE-ARRAY
Package

unicly

Source

unicly-bridge.lisp (file)

Function: %uuid-string-to-octets NAME-ARG
Package

unicly

Source

unicly-bridge.lisp (file)

Function: %uuid-uuid-version-if UUID-TIME-HIGH-AND-VERSION UUID
Package

unicly

Source

unicly-uuid-version.lisp (file)

Function: %uuid-version-bit-vector-if UUID-BIT-VECTOR
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: %uuid_byte-array-16-ub8-reqeust BYTE-ARRAY OFFSET
Package

unicly

Source

unicly-integers.lisp (file)

Function: %uuid_clock-seq-and-reserved-request BYTE-ARRAY

Steps seven and eight of RFC4122 Section 4.3:

Step seven:

- Set the clock_seq_hi_and_reserved field to octet 8 of the digest hash.

Step eight:

- Set the two most significant bits (bits 6 and 7) of the clock_seq_hi_and_reserved to zero and one, respectively. IOW, set bit 6 to 0 - Set bit 7 to 1

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly.lisp (file)

Function: %uuid_clock-seq-and-reserved-request-bit-vector BIT-VECTOR-128
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: %uuid_clock-seq-low-request BYTE-ARRAY

Step nine of RFC4122 Section 4.3:

- Set the clock_seq_low field to octet 9 of the hash.

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly.lisp (file)

Function: %uuid_clock-seq-low-request-bit-vector BIT-VECTOR-128
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: %uuid_node-request BYTE-ARRAY

Step ten or RFC4122 Section 4.3:

- Set octets zero through five of the node field to octets 10 through 15 of the digest hash.

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly.lisp (file)

Function: %uuid_node-request-bit-vector BIT-VECTOR-128
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: %uuid_time-high-and-version-request BYTE-ARRAY VERSION

Steps five and six of RFC4122 Section 4.3:

Step five:

- Set octets zero and one of the time_hi_and_version field to octets 6 and 7 of the digest hash.

Step six:

- Set the four most significant bits (bits 12 through 15) of the time_hi_and_version field to the appropriate 4-bit version number per the table below.

Msb0 Msb1 Msb2 Msb3 Version
0 1 0 1 5
0 0 1 1 3
0 1 0 0 4 ; :NOTE Not relevant to this operation.

MSB LSB
0 0 1 1 0 0 0 0 0 0 1 1 1 0 0 1 ; v3
0 1 0 1 0 0 0 0 0 0 1 1 1 0 0 1 ; v5
0 1 0 0 0 0 0 0 0 0 1 1 1 0 0 1 ; v4
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
!———!

UUID v3 bit-field
12345 => #b0011000000111001 (length "0011000000111001") => 16 #b0011000000111001
!–!

UUID v5 bit-field
20759 => #b0101000100010111 (length "0101000100010111") => 16 #b0101000100010111
!–!

UUID v4 bit-field
:NOTE Per RFC 4.1.3 bit 48 in a uuid-bit-vector-128 should always be 0. :EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly.lisp (file)

Function: %uuid_time-high-and-version-request-bit-vector BIT-VECTOR-128
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: %uuid_time-low-request BYTE-ARRAY

Step three of RFC4122 Section 4.3:

- Set octets zero through 3 of the time_low field to octets zero through 3 of the digest hash.

:EXAMPLE

(%uuid_time-low-request (uuid-get-namespace-bytes (make-v5-uuid *uuid-namespace-dns* "bubba")))

(%uuid_time-low-request (uuid-get-namespace-bytes (make-v3-uuid *uuid-namespace-dns* "bubba")))

(%uuid_time-low-request (uuid-get-namespace-bytes (make-v4-uuid *uuid-namespace-dns* "bubba")))

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly.lisp (file)

Function: %uuid_time-low-request-bit-vector BIT-VECTOR-128
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: %uuid_time-mid-request BYTE-ARRAY

Step four of RFC4122 Section 4.3:

- Set octets zero and one of the time_mid field to octets 4 and 5 of the digest hash.

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly.lisp (file)

Function: %uuid_time-mid-request-bit-vector BIT-VECTOR-128
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: %verify-digest-version CHK-VERSION

Return one of the symbols :MD5 or :SHA1 depending on value of CHK-VERSION. When CHK-VERSION is 3 return :MD5

When CHK-VERSION is 5 return :SHA1

CHK-VERSION should satisfy ‘%verify-version-3-or-5’, an error is signaled if not.

Helper function for ‘uuid-digest-uuid-string’

:EXAMPLE

(%verify-digest-version 3)

(%verify-digest-version 5)

;; Following fails successfully:

(%verify-digest-version 6)

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly.lisp (file)

Function: %verify-non-empty-name-arg NAME-ARG

If value of ‘unicly::*uuid-allow-empty-string-name-args*’ is T retrun NAME-ARG.

If value of NAME-ARG is of type ‘unicly::string-not-empty’ retrun NAME-ARG,
if not and error is signaled.

:EXAMPLE

(%verify-non-empty-name-arg "bubba")
(let ((*uuid-allow-empty-string-name-args* t))
(%verify-non-empty-name-arg ""))
(null (ignore-errors (%verify-non-empty-name-arg "")))
:SEE-ALSO ‘unicly::verify-sane-namespace-and-name’, ‘unicly::%verify-non-null-namespace-arg’.

Package

unicly

Source

unicly-null-check.lisp (file)

Function: %verify-non-null-namespace-arg NAMESPACE-ARG
Package

unicly

Source

unicly-null-check.lisp (file)

Function: %verify-slot-boundp-and-type VERIFY-UUID

Check that VERIFY-UUID has all slots ‘cl:slot-boundp’ and of the correct type.

Signal either a ‘cl:simple-condition’ or ‘cl:type-error’ error if not.

Helper function for ‘uuid-copy-uuid’.

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-class.lisp (file)

Function: %verify-valid-subclass-and-slots SUBCLASS-TO-VERIFY

Return SUBCLASS-TO-VERIFY when SUBCLASS-TO-VERIFY satisfies both:

‘unicly::%verify-valid-uuid-subclass-type’ ‘unicly::%verify-valid-uuid-subclass-slots’

If not, an error is signaled.

SUBCLASS-TO-VERIFY is a symbol designating a class which subclasses the class ‘unicly:unique-universal-identifier’.

:EXAMPLE

(%verify-valid-subclass-and-slots ’indexable-uuid) ; assuming it exists

(null (ignore-errors (%verify-valid-subclass-and-slots ’unique-universal-identifier)))

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-extend.lisp (file)

Function: %verify-valid-uuid-subclass-slots CLASS-TO-VERIFY

Instantiate an instance of CLASS-TO-VERIFY as if by ‘cl:make-instance’ and
ensure that each slot of the class ’unicly:unique-universal-identifier is
‘cl:slot-exists-p’ for the instantiated instance and that their default
‘cl:slot-value’ is ‘cl:zerop’, if so return CLASS-TO-VERIFY, if not, an error is
signaled.

:EXAMPLE

(%verify-valid-uuid-subclass-slots ’unique-universal-identifier)

:NOTE The evaluation of ‘cl:make-instance’ should finalize CLASS-TO-VERIFY if it is not already.

:NOTE This function is evaluated _after_ ‘unicly::%verify-valid-uuid-subclass’
by ‘unicly::%verify-valid-subclass-and-slots’ and is not evaluated when class CLASS-TO-VERIFY is not a valid subclass of the class ‘unicly::unique-universal-identifier’

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-extend.lisp (file)

Function: %verify-valid-uuid-subclass-type MAYBE-VALID-UUID-SUBCLASS

Return MAYBE-VALID-UUID-SUBCLASS if it is verifiably ‘cl:subtypep’ the class ‘unicly:unique-universal-identifier’ and not ‘cl:eq’ the symbol UNIQUE-UNIVERSAL-IDENTIFIER, an error is signaled if not.

MAYBE-VALID-UUID-SUBCLASS is a symbol designating a subclass.

:EXAMPLE

(null (ignore-errors (%verify-valid-uuid-subclass-type ’unique-universal-identifier)))

(null (ignore-errors (%verify-valid-uuid-subclass-type 42)))

(null (ignore-errors (%verify-valid-uuid-subclass-type ’cl:structure-class)))

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-extend.lisp (file)

Function: %verify-version-3-or-5 ()

Verify that arg VERSION is either the integer 3 or 5.

Signal an error if not.
Helper function for ‘digested-v3or5-uuid’.

:EXAMPLE

(%verify-version-3-or-5 3)

(%verify-version-3-or-5 5)

;; Following fails successfully:

(%verify-version-3-or-5 6)

:SEE-ALSO ‘%verify-digest-version’.

Package

unicly

Source

unicly.lisp (file)

Function: digested-v3-uuid V3-DIGEST-BYTE-ARRAY
Package

unicly

Source

unicly.lisp (file)

Function: digested-v3or5-uuid DIGEST-BYTE-ARRAY DIGEST-3-OR-5

Helper function to format UUIDv3 and UUIDv5 hashes according to UUID-VERSION.

DIGEST-BYTE-ARRAY is an argument suitable as the BYTE-ARRAY arg to ‘uuid-request-integer’.

DIGEST-BYTE-ARRAY is as per the the return value of ‘digested-v3or5-uuid’
UUID-VERSION should satisfy ‘%verify-version-3-or-5’, an error is signaled if not.

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly.lisp (file)

Function: digested-v5-uuid V5-DIGEST-BYTE-ARRAY
Package

unicly

Source

unicly.lisp (file)

Function: doc-set NAME OBJECT-TYPE STRING ARGS
Package

unicly

Source

unicly-utils.lisp (file)

Function: fundoc NAME &optional STRING &rest ARGS
Package

unicly

Source

unicly-utils.lisp (file)

Function: generic-doc FUNCTION-DESIGNATOR &optional DOC-STRING &rest ARGS
Package

unicly

Source

unicly-utils.lisp (file)

Function: hexadecimal-char-p MAYBE-HEX-CHAR
Package

unicly

Source

unicly-utils.lisp (file)

Function: make-uuid-from-string-if UUID-HEX-STRING-36-IF

Helper function for ‘make-uuid-from-string’.

If UUID-HEX-STRING-36-IF satisfies ‘uuid-hex-string-36-p’ return it. If the constraint fails signal a ‘mon:simple-error-mon’ condition.

:EXAMPLE

(make-uuid-from-string-if "6ba7b810-9dad-11d1-80b4-00c04fd430c8")

(make-uuid-from-string-if "6ba7b810-9dad–11d1-80b4-00c04fd430c8")

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-string-uuid.lisp (file)

Function: method-doc GENERIC-FUNCTION-DESIGNATOR QUALIFIERS SPECIALIZERS &optional DOC-STRING &rest ARGS
Package

unicly

Source

unicly-utils.lisp (file)

Function: simple-string-compat-p MAYBE-SIMPLE-STRING-COMPAT
Package

unicly

Source

unicly-utils.lisp (file)

Function: string-all-hex-char-p MAYBE-HEX-STRING
Package

unicly

Source

unicly-utils.lisp (file)

Function: string-not-null-or-empty-p STR
Package

unicly

Source

unicly-utils.lisp (file)

Function: string-with-fill-pointer-check-type CHECKED-VAL
Package

unicly

Source

unicly-types.lisp (file)

Function: string-with-fill-pointer-p MAYBE-OBJECT-OF-TYPE
Package

unicly

Source

unicly-types.lisp (file)

Function: type-specifier-p OBJECT
Package

unicly

Source

unicly-utils.lisp (file)

Function: typedoc NAME &optional STRING &rest ARGS
Package

unicly

Source

unicly-utils.lisp (file)

Function: uuid-assemble-ub16 B1 B2

Return an integer of type ‘uuid-ub48’ constructed of the uuid-ub8 octets B1 and B2.

HIGH —> LOW
B1 ... B6

:EXAMPLE

(let ((ub16 #xFFFF))
(multiple-value-bind (b1 b2) (uuid-disassemble-ub16 ub16)
(eql (uuid-assemble-ub16 b1 b2) ub16)))

:SEE-ALSO ‘uuid-assemble-ub48’, ‘uuid-assemble-ub32’,
‘uuid-disassemble-ub48’, ‘uuid-disassemble-ub32’, ‘uuid-disassemble-ub16’, ‘uuid-request-integer’, ‘uuid-byte-array-16-to-integer’.

Package

unicly

Source

unicly-integers.lisp (file)

Function: uuid-assemble-ub32 B1 B2 B3 B4

Return an integer of type ‘uuid-ub32’ constructed of the uuid-ub8 octets B1, B2, B3, and B4.

HIGH —> LOW
B1 ... B4

:EXAMPLE

(let ((ub32 #xFFFFFFFF))
(multiple-value-bind (b1 b2 b3 b4) (uuid-disassemble-ub32 ub32)
(eql (uuid-assemble-ub32 b1 b2 b3 b4) ub32)))

:SEE-ALSO ‘uuid-assemble-ub48’, ‘uuid-assemble-ub16’,
‘uuid-disassemble-ub48’, ‘uuid-disassemble-ub32’, ‘uuid-disassemble-ub16’, ‘uuid-request-integer’, ‘uuid-byte-array-16-to-integer’.

Package

unicly

Source

unicly-integers.lisp (file)

Function: uuid-assemble-ub48 B1 B2 B3 B4 B5 B6

Return an integer of type ‘uuid-ub48’ constructed of the uuid-ub8 octets B1, B2, B3, B4, B5, and B6.

HIGH —> LOW
B1 ... B6

:EXAMPLE

(let ((ub48 #xFFFFFFFFFFFF))
(multiple-value-bind (b1 b2 b3 b4 b5 b6) (uuid-disassemble-ub48 ub48)
(eql (uuid-assemble-ub48 b1 b2 b3 b4 b5 b6) ub48)))

:SEE-ALSO ‘uuid-assemble-ub32’, ‘uuid-assemble-ub16’,
‘uuid-disassemble-ub48’, ‘uuid-disassemble-ub32’, ‘uuid-disassemble-ub16’, ‘uuid-request-integer’, ‘uuid-byte-array-16-to-integer’.

Package

unicly

Source

unicly-integers.lisp (file)

Function: uuid-bit-vector-128-check-type CHECKED-VAL
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-bit-vector-128-zeroed ()

Return a bit vector of 128 elements with all elements zeroed.

:EXAMPLE

(uuid-bit-vector-128-zeroed)

(typep (uuid-bit-vector-128-zeroed) ’uuid-bit-vector-128)

:SEE-ALSO ‘uuid-bit-vector-128’, ‘uuid-deposit-octet-to-bit-vector’, ‘uuid-byte-array-to-bit-vector’, ‘make-null-uuid’.

Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-bit-vector-16-check-type CHECKED-VAL
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-bit-vector-16-p MAYBE-OBJECT-OF-TYPE
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-bit-vector-16-zeroed ()
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-bit-vector-32-check-type CHECKED-VAL
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-bit-vector-32-p MAYBE-OBJECT-OF-TYPE
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-bit-vector-32-zeroed ()
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-bit-vector-48-check-type CHECKED-VAL
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-bit-vector-48-p MAYBE-OBJECT-OF-TYPE
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-bit-vector-48-zeroed ()
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-bit-vector-8-zeroed ()
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-bit-vector-build-offsets BIT-OFFSET BIT-WIDTH
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-bit-vector-to-integer BIT-VECTOR

Return BIT-VECTOR’s representation as a positive integer.

BIT-VECTOR is an object of type ‘cl:simple-bit-vector’.

:EXAMPLE

(uuid-bit-vector-to-integer (uuid-to-bit-vector (make-v4-uuid)))

:NOTE This is a modified version of a a "BIT-VECTOR-TO-INTEGER" function written by Stas Boukarev using ‘cl:flet’ and ‘cl:loop’.
:SEE :FILE unicly/unicly.lisp for additional details.

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-byte-array-16-check-type CHECKED-VAL
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-byte-array-20-check-type CHECKED-VAL
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-byte-array-20-p MAYBE-OBJECT-OF-TYPE

Whether MAYBE-UUID-BYTE-ARRAY-16 is of type ‘uuid-byte-array-20’.

Return T when MAYBE-UUID-BYTE-ARRAY-16 has the type signature:

(simple-array (unsigned-byte 8) (20))

:EXAMPLE

(uuid-byte-array-20-p (uuid-string-to-sha1-byte-array "bubba"))

:SEE-ALSO ‘uuid-hex-string-36’, ‘uuid-hex-string-36-p’.

Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-byte-array-check-type CHECKED-VAL
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-byte-array-p MAYBE-OBJECT-OF-TYPE
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-byte-string-check-type CHECKED-VAL
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-delimited-string-36-p MAYBE-DELIM-STRING-36

Whether MAYBE-DELIM-STRING-36 is potentially of type ‘uuid-hex-string-36’ or ‘uuid-hex-string-36-zeroed’

Return nil when MAYBE-DELIM-STRING-36 is not ‘uuid-string-36-p’.
Else, return as if by ‘cl:values’:
cl:nth-value-0 is T
cl:nth-value-1 is an object of type (simple-vector 5)
each elt of vector is a simple-string generated by splitting
MAYBE-DELIM-STRING-36 at occurences of #\-.
An object will satisfy ‘uuid-string-36-p’ when following constraints are met:

- Its type is ’(array character 36)
- When split to list of strings on the character delimter #\- the list is of length is 5
- The length of each string in the list matches the pattern 8-4-4-4-12
- each string in the list satisfies is a hexadecimal character or #\-

:EXAMPLE

(uuid-delimited-string-36-p (uuid-princ-to-string (make-v4-uuid)))

(uuid-delimited-string-36-p (uuid-princ-to-string (make-null-uuid)))

(uuid-delimited-string-36-p (make-string 36 :initial-element #\-))

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-deposit-octet-to-bit-vector OCTET OFFSET UUID-BV
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-deserialize-bit-vector-bits STREAM-IN
Package

unicly

Source

unicly-io.lisp (file)

Function: uuid-deserialize-byte-array-bytes STREAM-IN
Package

unicly

Source

unicly-io.lisp (file)

Function: uuid-digest-uuid-instance DIGEST-VERSION UUID-NAMESPACE-INSTANCE NAME

This is step two of RFC4122 Section 4.3:
- Compute the digest hash of the name space ID concatenated with the name.

DIGEST-VERSION is an interger value either (3 or 5) indicateing the type of hash to digest where 3 indicates :MD5 for a v3 UUID and 5 indicates :SHA1 for a v5 UUID. It should satisfy ‘%verify-digest-version’, and error is signaled if
not.

Arg UUID-NAMESPACE-INSTANCE is an instance of class ‘unique-universal-identifier’ indicating the namespace of NAME.
NAME is a string of arbitrary length and should be encoded as UTF-8 (or subset of).

When DIGEST-VERSION is 3 return value is an object of type ‘uuid-byte-array-16’ suitable for use as the V3-DIGEST-BYTE-ARRAY argument to ‘digested-v3-uuid’. When DIGEST-VERSION is 5 return value is an object of type ‘uuid-byte-array-20’ suitable for use as the V5-DIGEST-BYTE-ARRAY argument to ‘digested-v5-uuid’. :EXAMPLE

(uuid-digest-uuid-instance 3 *uuid-namespace-dns* "bubba")

(uuid-digest-uuid-instance 5 *uuid-namespace-dns* "bubba")

(uuid-byte-array-16-p (uuid-digest-uuid-instance 3 *uuid-namespace-dns* "bubba"))

(uuid-byte-array-20-p (uuid-digest-uuid-instance 5 *uuid-namespace-dns* "bubba"))

:SEE-ALSO ‘%uuid-digest-uuid-instance-md5’, ‘%uuid-digest-uuid-instance-sha1’.

Package

unicly

Source

unicly.lisp (file)

Function: uuid-disassemble-ub16 U16

Return two uuid-ub8 octets of U16 as if by ‘cl:values’.

U16 is an integer of type ‘uuid-ub16’ corresponding to either the ‘%uuid_time-high-and-version’ or ‘%uuid_time-mid’ slots of an instance of class ‘unique-universal-identifier’.

:EXAMPLE

(uuid-disassemble-ub16
(slot-value (make-v5-uuid *uuid-namespace-dns* "buuba") ’%uuid_time-mid))

(multiple-value-list (uuid-disassemble-ub16 13953))

(eq (nth-value 0 (uuid-disassemble-ub16 13953)) 54)

(eq (nth-value 0 (uuid-disassemble-ub16 13953)) 129)

:SEE-ALSO ‘uuid-disassemble-ub48’, ‘uuid-disassemble-ub32’, ‘uuid-disassemble-ub16’.

Package

unicly

Source

unicly-integers.lisp (file)

Function: uuid-disassemble-ub32 U32

Return U32 as four integer values of type ‘uuid-ub8’ as if by ‘cl:values’.

U32 is an integer of type ‘uuid-ub32’ corresponding to the ‘%uuid_time-low’ slot of an instance of class ‘unique-universal-identifier’.

:EXAMPLE

(slot-value (make-v4-uuid) ’%UUID_TIME-LOW)

(uuid-disassemble-ub32 (slot-value (make-v5-uuid *uuid-namespace-dns* "bubba")))

(equal (multiple-value-list (uuid-disassemble-ub16 13953)) ’(54 129))

:SEE-ALSO ‘uuid-disassemble-ub48’, ‘uuid-disassemble-ub32’, ‘uuid-disassemble-ub16’.

Package

unicly

Source

unicly-integers.lisp (file)

Function: uuid-disassemble-ub48 U48

Return U48 as six integer values of type uuid-ub8 as if by ‘cl:values’.

U48 is an integer of type ‘uuid-ub48’. corresponding to the ‘%uuid_node’ slot of an instance of class ‘unique-universal-identifier’.

:EXAMPLE

(multiple-value-list
(uuid-disassemble-ub48
(slot-value (make-v5-uuid *uuid-namespace-dns* "buuba") ’%uuid_node))) :SEE-ALSO ‘uuid-disassemble-ub48’, ‘uuid-disassemble-ub32’, ‘uuid-disassemble-ub16’.

Package

unicly

Source

unicly-integers.lisp (file)

Function: uuid-hex-vector-parse-clock-seq-and-reserved HEX-VECTOR-5
Package

unicly

Source

unicly-string-uuid.lisp (file)

Function: uuid-hex-vector-parse-clock-seq-low HEX-VECTOR-5
Package

unicly

Source

unicly-string-uuid.lisp (file)

Function: uuid-hex-vector-parse-node HEX-VECTOR-5
Package

unicly

Source

unicly-string-uuid.lisp (file)

Function: uuid-hex-vector-parse-time-high-and-version HEX-VECTOR-5
Package

unicly

Source

unicly-string-uuid.lisp (file)

Function: uuid-hex-vector-parse-time-low HEX-VECTOR-5
Package

unicly

Source

unicly-string-uuid.lisp (file)

Function: uuid-hex-vector-parse-time-mid HEX-VECTOR-5
Package

unicly

Source

unicly-string-uuid.lisp (file)

Function: uuid-integer-128-to-bit-vector UUID-INTEGER-128

Convert the decimal integer representation of a UUID to a ‘uuid-bit-vector-128’.

:EXAMPLE

(uuid-bit-vector-eql (uuid-integer-128-to-bit-vector 317192554773903544674993329975922389959)
(uuid-to-bit-vector (make-v5-uuid *uuid-namespace-dns* "bubba")))
(uuid-bit-vector-eql (uuid-integer-128-to-bit-vector 317192554773903544674993329975922389959)

(uuid-byte-array-to-bit-vector (uuid-integer-128-to-byte-array 317192554773903544674993329975922389959)))

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-integer-128-to-byte-array UUID-INTEGER
Package

unicly

Source

unicly-byte-arrays.lisp (file)

Function: uuid-octet-to-bit-vector-8 OCTET
Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: uuid-read-bit-vector-bits INPUT-PATHNAME &key IF-DOES-NOT-EXIST
Package

unicly

Source

unicly-io.lisp (file)

Function: uuid-request-integer ARRAY OFFSET LENGTH &key LITTLE-ENDIAN SIGN-EXTEND

Decode an integer of LENGTH octets from ARRAY starting at OFFSET.

The number represented by BYTE-ARRAY may be any positive integer representable in 48 bits.

The OFFSET is effectively :start and
LENGTH is :end where :end => (+ offset length)
x86-32 OSs are LITTLE-ENDIAN but network-byte-order is big-endian...

:EXAMPLE

(uuid-request-integer (uuid-number-to-byte-array 281474976710654) 0 6)

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-integers.lisp (file)

Function: uuid-serialize-bit-vector-bits BV-OR-UUID STREAM-OUT
Package

unicly

Source

unicly-io.lisp (file)

Function: uuid-serialize-byte-array-bytes UUID-OR-BYTE-ARRAY-16 STREAM-OUT

Serialize UUID to STREAM.

Bytes of UUID are written to STREAM.

Stream should have an :element-type ’(unsigned-byte 8).

:EXAMPLE

(let ((file (make-pathname :directory ’(:absolute "tmp")
:name "temp-bytes"))
(w-uuid (make-v5-uuid *uuid-namespace-dns* "bubba"))
(gthr ’()))
(with-open-file (s file
:if-exists :supersede
:if-does-not-exist :create
:direction :output
:element-type ’uuid-ub8)
(uuid-serialize-byte-array-bytes w-uuid s))
(with-open-file (stream file :element-type ’uuid-ub8)
(do ((code (read-byte stream nil :eof) (read-byte stream nil :eof)))
((eql code :eof))
(push code gthr)))
(and gthr
(setf gthr (uuid-from-byte-array (make-array 16
:element-type ’uuid-ub8 :initial-contents (nreverse gthr))))) (unwind-protect
(list (uuid-eql w-uuid gthr)
gthr
w-uuid)
(delete-file file)))

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-io.lisp (file)

Function: uuid-simple-type-error &key DATUM EXPECTED-TYPE

Convenience function for signaling conditions of type ‘unicly::uuid-simple-type-error’.

Keywords DATUM and EXPECTED-TYPE are as per condition class CL:TYPE-ERROR.

:EXAMPLE

(uuid-simple-type-error :datum "bubba" :expected-type ’simple-bit-vector)

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-conditions.lisp (file)

Function: uuid-simple-vector-5-check-type CHECKED-VAL
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-simple-vector-5-p MAYBE-OBJECT-OF-TYPE
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-string-32-check-type CHECKED-VAL
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-string-36-check-type CHECKED-VAL
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-to-byte-array UUID

Convert UUID to a byte-array.

Arg UUID should be an instance of the UNIQUE-UNIVERSAL-IDENTIFIER class.

Return value is an array of type ‘uuid-byte-array-16’ with the type signature:

(simple-array (unsigned-byte 8) (16))

It will satisfy the predicate ‘uuid-byte-array-16-p’.

:EXAMPLE

(uuid-get-namespace-bytes *uuid-namespace-dns*)

:SEE-ALSO ‘uuid-from-byte-array’.

Package

unicly

Source

unicly-byte-arrays.lisp (file)

Function: uuid-valid-stream-p MAYBE-STREAM

Whether STREAM is ‘cl:streamp’ and ‘cl:open-stream-p’. Return as if by ‘cl:values’:

cl:nth-value 0 is a boolean
cl:nth-value 1 is value of STREAM arg

:EXAMPLE

(let ((os (make-string-output-stream))) (unwind-protect
(uuid-valid-stream-p os)
(close os)))

(uuid-valid-stream-p "bubba")

:SEE-ALSO ‘uuid-valid-stream-verify-io-type’, ‘uuid-valid-stream-verify-for-input’, ‘uuid-valid-stream-verify-for-output’.

Package

unicly

Source

unicly-io.lisp (file)

Function: uuid-valid-stream-verify-for-input IN-STREAM

Return STREAM if it is valid for use as when reading a UUID representation.

Signal an error if STREAM is not true for either ‘uuid-valid-stream-p’ or ‘cl:input-stream-p’.

:EXAMPLE

(let ((stream-in (make-string-input-stream "bubba is ok"))
(stream-read (make-array 11 :element-type ’character)))
(values (uuid-valid-stream-verify-for-input stream-in)
(progn (read-sequence stream-read stream-in )
stream-read)))

;; Following fails succesfully:

(uuid-valid-stream-verify-for-input "bubba")

:SEE-ALSO ‘uuid-valid-stream-verify-io-type’,
‘uuid-valid-stream-verify-for-output’.

Package

unicly

Source

unicly-io.lisp (file)

Function: uuid-valid-stream-verify-for-output OUT-STREAM

Return STREAM if it is valid for use as when writing a UUID representation.

Signal an error if STREAM is not true for either ‘uuid-valid-stream-p’ or ‘cl:outpu-stream-p’.

:EXAMPLE

(with-output-to-string (bubba)
(and (uuid-valid-stream-verify-for-output bubba)
(princ "bubba is ok" bubba)))

;; Following fails succesfully:

(uuid-valid-stream-verify-for-output "bubba")

:SEE-ALSO ‘uuid-valid-stream-verify-io-type’, ‘uuid-valid-stream-verify-for-input’.

Package

unicly

Source

unicly-io.lisp (file)

Function: uuid-valid-stream-verify-io-octet-type MAYBE-OCTET-STREAM &key DIRECTION
Package

unicly

Source

unicly-io.lisp (file)

Function: uuid-valid-stream-verify-io-type MAYBE-VALID-IO-STREAM &key DIRECTION

Return STREAM if it is valid for use as when writing a UUID representation.

Keyword DIRECTION is as per ‘cl:open’. Valid values are either:

:INPUT :OUTPUT

An error is signaled if STREAM is not ‘uuid-valid-stream-p’.

When DIRECTION is :OUTPUT and stream is not ‘cl:output-stream-p’ an error is signaled.

When DIRECTION is :INPUT and stream is not ‘cl:input-stream-p’ an error is signaled.

:SEE-ALSO ‘uuid-valid-stream-verify-io-type’, ‘uuid-valid-stream-verify-for-input’,
‘uuid-valid-stream-verify-for-output’.

Package

unicly

Source

unicly-io.lisp (file)

Function: uuid-valid-stream-verify-octet-stream-for-input MAYBE-INPUT-OCTET-STREAM
Package

unicly

Source

unicly-io.lisp (file)

Function: uuid-valid-stream-verify-octet-stream-for-output MAYBE-OUTPUT-OCTET-STREAM
Package

unicly

Source

unicly-io.lisp (file)

Function: uuid-verify-bit-vector-simplicity PUTATIVE-SIMPLE-BIT-VECTOR
Package

unicly

Source

unicly-types.lisp (file)

Function: uuid-version-bit-vector UUID-BIT-VECTOR

Return the version of uuid version of UUID-BIT-VECTOR.

UUID-BIT-VECTOR is on object of type ‘uuid-bit-vector-128’.

When object is the null uuid return as if by ‘cl:values’:
0,null-uuid

If for some reason bit 48 of object is not ‘cl:zerop’ an error is signaled.

:EXAMPLE

(uuid-version-bit-vector (uuid-to-bit-vector (make-v4-uuid)))

(uuid-version-bit-vector (uuid-to-bit-vector
(make-v5-uuid *uuid-namespace-dns* "bubba")))

(uuid-version-bit-vector (uuid-to-bit-vector
(make-v3-uuid *uuid-namespace-dns* "bubba")))

(uuid-version-bit-vector (uuid-to-bit-vector (make-null-uuid)))

;; Following successfully signals an error:

(let ((bv-z (uuid-bit-vector-128-zeroed)))
(setf (sbit bv-z 48) 1)
(uuid-version-bit-vector bv-z))

:SEE-ALSO ‘uuid-version-bit-vector’, ‘uuid-bit-vector-v3-p’, ‘uuid-bit-vector-v4-p’ ‘uuid-bit-vector-v5-p’, ‘uuid-bit-vector-128’, ‘uuid-eql’.

Package

unicly

Source

unicly-bit-vectors.lisp (file)

Function: vardoc NAME &optional STRING &rest ARGS
Package

unicly

Source

unicly-utils.lisp (file)

Function: vector-with-fill-pointer-p OBJECT
Package

unicly

Source

unicly-utils.lisp (file)

Function: verify-sane-namespace-and-name NAMESPACE NAME

Return as if by cl:values the uuid-byte-array representations of NAMESPACE and NAME.

NAMESPACE is an object of type ‘unicly:unique-universal-identifier’.

NAME is a string.

Depending on value of special variables:

‘*uuid-allow-null-like-namespace-args*’ ‘*uuid-allow-empty-string-name-args*’

Signal an error if NAMESPACE is a null-uuid not satisfying ‘unique-universal-identifier-null-p’. Siganl an error if NAME fails to satisfy ‘unicly::%string-not-empty-p’.
:EXAMPLE

(verify-sane-namespace-and-name (make-v4-uuid) "bubba")

(let ((*uuid-allow-empty-string-name-args* t))
(verify-sane-namespace-and-name (make-v4-uuid) ""))

(null (ignore-errors (verify-sane-namespace-and-name (make-v4-uuid) "")))

(let ((*uuid-allow-null-like-namespace-args* t))
(verify-sane-namespace-and-name (make-instance ’unique-universal-identifier) "bubba"))

(let ((*uuid-allow-null-like-namespace-args* t)
(*uuid-allow-empty-string-name-args* t))
(verify-sane-namespace-and-name (make-instance ’unique-universal-identifier) ""))

:SEE-ALSO ‘unicly::%verify-non-empty-name-arg’, ‘unicly::%verify-non-null-namespace-arg’.

Package

unicly

Source

unicly-null-check.lisp (file)


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

5.2.6 Generic functions

Generic Function: uuid-bit-48-error-datum CONDITION
Package

unicly

Methods
Method: uuid-bit-48-error-datum (CONDITION uuid-bit-48-error)
Source

unicly-conditions.lisp (file)

Generic Function: uuid-bit-48-error-expected-type CONDITION
Package

unicly

Methods
Method: uuid-bit-48-error-expected-type (CONDITION uuid-bit-48-error)
Source

unicly-conditions.lisp (file)

Generic Function: uuid-print-bytes STREAM UUID

Print the bytes of UUID in a format suitable to its class to STREAM.

UUID an object representing an instance of ‘unique-universal-identifier’ class or subclass.

STREAM is an output-stream.

:SEE-ALSO ‘uuid-print-bytes-to-string’.

Package

unicly

Source

unicly-class.lisp (file)

Methods
Method: uuid-print-bytes STREAM (UUID unique-universal-identifier)

Print the raw bytes of UUID in hexadecimal format to STREAM.

UUID is an instance of ‘unique-universal-identifier’ class.

STREAM is an output-stream.

Output of return value has the format:

6ba7b8109dad11d180b400c04fd430c8

:EXAMPLE

(uuid-print-bytes nil (make-v4-uuid))

(uuid-print-bytes t (make-v4-uuid))

:NOTE Per RFC4122 Section 3. "Namespace Registration Template" ,—-
| The hexadecimal values "a" through "f" are output as
| lower case characters and are case insensitive on input. ‘—-

:SEE-ALSO ‘uuid-print-bytes-to-string’.

Generic Function: uuid-slot-unbound-name CONDITION
Package

unicly

Methods
Method: uuid-slot-unbound-name (CONDITION uuid-slot-unbound-error)
Source

unicly-conditions.lisp (file)

Generic Function: uuid-slot-unbound-object CONDITION
Package

unicly

Methods
Method: uuid-slot-unbound-object (CONDITION uuid-slot-unbound-error)
Source

unicly-conditions.lisp (file)


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

5.2.7 Conditions

Condition: uuid-bit-48-error ()

Condition for uuid related objects whose bit 48 is not ‘cl:zerop’.

UUID-BIT-48-ERROR-DATUM is the object of the offending error.

- When it is of type ‘unicly:unique-universal-identifier’ this indicates that
Msb0 (byte 1 15) of the ’%uuid_time-high-and-version slot-value is 1.

- When it is of type ‘unicly:uuid-bit-vector-128’ this indicates that
(sbit UUID-BIT-48-ERROR-DATUM 48) is 1.

UUID-BIT-48-ERROR-EXPECTED-TYPE is a type specifier, it is defaulted to (mod 1).

:EXAMPLE

(error (make-condition ’uuid-bit-48-error :uuid-bit-48-error-datum (make-v4-uuid)))

(error (make-condition ’uuid-bit-48-error :uuid-bit-48-error-datum (uuid-bit-vector-128-zeroed)))

(error (make-condition ’uuid-bit-48-error :uuid-bit-48-error-datum (make-null-uuid)))

:NOTE Above examples are for illustrative purposes only, the reported objects
are in fact valid. Following examples are for legitimately invalid objects.

(let ((v4uuid (make-v4-uuid)))
(setf (slot-value v4uuid ’%uuid_time-high-and-version) #xFFFF)
(%uuid-version-uuid-if (slot-value v4uuid ’%uuid_time-high-and-version) v4uuid))

(let* ((v4uuid (make-v4-uuid))
(v4-bv (uuid-to-bit-vector v4uuid)))
(setf (sbit v4-bv 48) 1)
(%uuid-version-bit-vector-if v4-bv))

:NOTE Intended callers of this condition are internal unicly dispatching functions:
- ‘unicly::%uuid-version-uuid-if’
- ‘unicly::%uuid-version-bit-vector-if’

Under normal circumstances, neither of these functions likely to ever siganl
so long as their arguments are uuid objects properly instantiated via the exposed
unicly API, e.g. with ‘unicly:make-v[345]-uuid’. However, it is possible for an
abstract representation of a uuid to be corrupt such that uuid objects
instantiated from them by way of:
- ‘unicly:make-uuid-from-string’
- ‘unicly:uuid-from-byte-array’
- ‘unicly:uuid-from-bit-vector’

Where the resultant uuid could be faulty w/r/t its uuid version we should identify it.

Of more concern are attempts to migrate uuid objects with origins from
the equivalent UUID API esp. where it may create spurious uuid objects by way of ‘uuid:make-v1-uuid’ which sets the wrong bits of the class uuid’s
time-high-and-version slot-value. It is wrong to propogate the errors of that implementations API further and we make some attempt to identify them.

:SEE-ALSO ‘uuid-version-uuid’, ‘uuid-version-bit-vector’.

Package

unicly

Source

unicly-conditions.lisp (file)

Direct superclasses

uuid-error (condition)

Direct methods
Direct slots
Slot: uuid-bit-48-error-datum
Initargs

:uuid-bit-48-error-datum

Readers

uuid-bit-48-error-datum (generic function)

Slot: uuid-bit-48-error-expected-type
Initform

(quote (quote (mod 1)))

Readers

uuid-bit-48-error-expected-type (generic function)

Condition: uuid-error ()

Superclass for all errors related to unicly.

Package

unicly

Source

unicly-conditions.lisp (file)

Direct superclasses

error (condition)

Direct subclasses
Condition: uuid-simple-error ()

Conditions for simple unicly errors.

Package

unicly

Source

unicly-conditions.lisp (file)

Direct superclasses
Direct subclasses

uuid-simple-type-error (condition)

Direct Default Initargs
InitargValue
:format-argumentsnil
:format-control"uuid-simple-error"
Condition: uuid-simple-type-error ()

Conditions for failed Unicly type declarations.

Keyword FORMAT-CONTROL has a default-initarg which displays as:

UUID-SIMPLE-TYPE-ERROR
got-val: <GOT>
type-of: <DATUM-TYPE-OF>
expected: <EXPECTED-TYPE>

Do not override FORMAT-CONTROL by providing an alternative argument as keyword FORMAT-ARGUMENTS is ignored.

Keywords DATUM and EXPECTED-TYPE are as per condition class CL:TYPE-ERROR.

Convenience function ‘uuid-simple-type-error’ is provided for signalling this condition.

:EXAMPLE

(error ’uuid-simple-type-error :datum "bubba" :expected-type ’simple-bit-vector)

(uuid-simple-type-error :datum "bubba" :expected-type ’simple-bit-vector)

Package

unicly

Source

unicly-conditions.lisp (file)

Direct superclasses
Direct Default Initargs
InitargValue
:format-control"uuid-simple-type-error~%~tgot-val: ~s~%~ttype-of: ~s~%~texpected: ~s~t"
Condition: uuid-slot-type-error ()

Conditions for unicly slot-type errors.

Package

unicly

Source

unicly-conditions.lisp (file)

Direct superclasses
Condition: uuid-slot-unbound-error ()

Condition for ‘unicly:unique-universal-identifier’ objects with unbound slots.

UUID-SLOT-UNBOUND-NAME is a symbol naming the unbound slot in object.

UUID-SLOT-UNBOUND-OBJECT is the uuid instance of with the unbound slot.

:EXAMPLE

(let ((v4uuid (make-v4-uuid)))
(slot-makunbound v4uuid ’%uuid_time-high-and-version)
(error ’uuid-slot-unbound-error
:uuid-slot-unbound-name ’%uuid_time-high-and-version :uuid-slot-unbound-object v4uuid))

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-conditions.lisp (file)

Direct superclasses

uuid-error (condition)

Direct methods
Direct slots
Slot: uuid-slot-unbound-name
Initargs

:uuid-slot-unbound-name

Readers

uuid-slot-unbound-name (generic function)

Slot: uuid-slot-unbound-object
Initargs

:uuid-slot-unbound-object

Readers

uuid-slot-unbound-object (generic function)


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

5.2.8 Classes

Class: unique-universal-identifier-null ()

Like instances of ‘unicly:unique-universal-identifier’ but with all slots zeroed.

There should only ever be one instance of this class and it should be the value
of the special variable ‘unicly::*uuid-null-uuid*’.

User code should neither set nor access the slot-values of this class, instead
user code may gain access to a valid null-uuid with ‘make-null-uuid’.

Though the consequences are undefined, it is an error for any slot-value of an instance of this class to be non-zero.

,—- RFC4122 section 4.1.7. "Nil UUID"
| The nil UUID is special form of UUID that is specified to have all
| 128 bits set to zero.
‘—-

Following returns true when object is of type ‘unicly:unique-universal-identifier-null’.

(slot-exists-p *uuid-null-uuid* ’%uuid_null)

Instance of this class return T for both ‘unicly:uuid-eql’ and ‘unicly:uuid-bit-vector-eql’ however not two null-uuids share identity under ‘cl:eq’, ‘cl:eql’, ‘cl:equal’, ‘cl:equalp’:

(eq (make-instance ’unique-universal-identifier-null)
(make-instance ’unique-universal-identifier))

(eql (make-instance ’unique-universal-identifier)
(make-instance ’unique-universal-identifier))

(equal (make-instance ’unique-universal-identifier)
(make-instance ’unique-universal-identifier))

(equalp (make-instance ’unique-universal-identifier)
(make-instance ’unique-universal-identifier))

:SEE-ALSO ‘make-null-uuid’.

Package

unicly

Source

unicly-class.lisp (file)

Direct superclasses

unique-universal-identifier (class)

Direct methods
Direct slots
Slot: %uuid_null
Initform

t


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

5.2.9 Types

Type: char-compat ()
Package

unicly

Source

unicly-bridge.lisp (file)

Type: hexadecimal-char ()
Package

unicly

Source

unicly-utils.lisp (file)

Type: not-null ()
Package

unicly

Source

unicly-utils.lisp (file)

Type: simple-string-compat ()
Package

unicly

Source

unicly-bridge.lisp (file)

Type: simple-string-n-length-compat SIZE
Package

unicly

Source

unicly-bridge.lisp (file)

Type: stream-or-boolean ()
Package

unicly

Source

unicly-utils.lisp (file)

Type: stream-or-boolean-or-string-with-fill-pointer ()
Package

unicly

Source

unicly-utils.lisp (file)

Type: string-compat ()
Package

unicly

Source

unicly-bridge.lisp (file)

Type: string-empty ()
Package

unicly

Source

unicly-utils.lisp (file)

Type: string-n-length-compat SIZE
Package

unicly

Source

unicly-bridge.lisp (file)

Type: string-not-empty ()
Package

unicly

Source

unicly-utils.lisp (file)

Type: string-not-null-or-empty ()
Package

unicly

Source

unicly-utils.lisp (file)

Type: string-or-null ()
Package

unicly

Source

unicly-utils.lisp (file)

Type: string-with-fill-pointer ()
Package

unicly

Source

unicly-utils.lisp (file)

Type: uuid-bit-vector &optional SIZE

An object of type (simple-bit-vector <LENGTH>).
Objects of this type are capable of representing as bit-vectors the integer values of slots of class ‘unique-universal-identifier’.

:EXAMPLE

(typep (uuid-bit-vector-128-zeroed) ’uuid-bit-vector)

:SEE-ALSO ‘uuid-bit-vector’, ‘uuid-bit-vector-128’, ‘uuid-bit-vector-48’, ‘uuid-bit-vector-32’, ‘uuid-bit-vector-16’, ‘uuid-bit-vector-8’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-bit-vector-128 ()

An object of type (simple-bit-vector 128) capable of representing all 128 bits of a ‘unique-universal-identifier’

Objects of this type have a length of type ‘uuid-bit-vector-128-length’ and may be used to represent the integer value of the combined slots of class ‘unique-universal-identifier’.

:EXAMPLE

(typep (uuid-bit-vector-128-zeroed) ’uuid-bit-vector-128)

:SEE-ALSO ‘uuid-bit-vector’, ‘uuid-bit-vector-128’, ‘uuid-bit-vector-48’, ‘uuid-bit-vector-32’, ‘uuid-bit-vector-16’, ‘uuid-bit-vector-8’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-bit-vector-128-length ()

An object of type (uuid-bit-vector-length 128).

Objects of this type correspond with the length of a simple-bit-vector of type ‘uuid-bit-vector-128’ which are used to represent the integer value of the combined slots of class ‘unique-universal-identifier’.

:EXAMPLE

(typep 128 ’(uuid-bit-vector-128-length)) => T

(typep 127 ’(uuid-bit-vector-127-length)) => NIL

:SEE-ALSO ‘uuid-bit-vector-length’, ‘uuid-bit-vector-128-length’, ‘uuid-bit-vector-48-length’, ‘uuid-bit-vector-32-length’, ‘uuid-bit-vector-16-length’, ‘uuid-bit-vector-8-length’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-bit-vector-16 ()

An object of type (simple-bit-vector 16) capable of representing 16
bits of a ‘unique-universal-identifier’

Objects of this type have a length of type ‘uuid-bit-vector-16-length’, and may be used to represent the integer values of the slots ‘%uuid_time-mid’ and ‘%uuid_time-mid’ of class ‘unique-universal-identifier’.

:EXAMPLE

(typep (subseq (uuid-bit-vector-128-zeroed) 0 16) ’uuid-bit-vector-16)

(typep (uuid-bit-vector-128-zeroed) ’uuid-bit-vector-128)

:SEE-ALSO ‘uuid-bit-vector’, ‘uuid-bit-vector-128’, ‘uuid-bit-vector-48’, ‘uuid-bit-vector-32’, ‘uuid-bit-vector-16’, ‘uuid-bit-vector-8’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-bit-vector-16-length ()

An object of type (uuid-bit-vector-length 16).

Objects of this type correspond with the length of a simple-bit-vector of type ‘uuid-bit-vector-16’ which are used to represent the integer values of the slots ‘%uuid_time-mid’ and ‘%uuid_time-high-and-version’ of class ‘unique-universal-identifier’.

:EXAMPLE

(typep 16 ’(uuid-bit-vector-16-length)) => T

(typep 17 ’(uuid-bit-vector-16-length)) => NIL

:SEE-ALSO ‘uuid-bit-vector-length’, ‘uuid-bit-vector-128-length’, ‘uuid-bit-vector-48-length’, ‘uuid-bit-vector-32-length’, ‘uuid-bit-vector-16-length’, ‘uuid-bit-vector-8-length’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-bit-vector-32 ()

An object of type (simple-bit-vector 32) capable of representing 32
bits of a ‘unique-universal-identifier’

Objects of this type have a length of type ‘uuid-bit-vector-32-length’, and may be used to represent the integer values of the slot ‘%uuid_time-low’ of class ‘unique-universal-identifier’.

:EXAMPLE

(typep (subseq (uuid-bit-vector-128-zeroed) 0 32) ’uuid-bit-vector-32)

(typep (uuid-bit-vector-128-zeroed) ’uuid-bit-vector-32)

:SEE-ALSO ‘uuid-bit-vector’, ‘uuid-bit-vector-128’, ‘uuid-bit-vector-48’, ‘uuid-bit-vector-32’, ‘uuid-bit-vector-16’, ‘uuid-bit-vector-8’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-bit-vector-32-length ()

An object of type (uuid-bit-vector-length 32).

Objects of this type correspond with the length of a simple-bit-vector of type ‘uuid-bit-vector-32’ which are used to represent the integer values of the slot ‘%uuid_time-low’ of class ‘unique-universal-identifier’.

:EXAMPLE

(typep 32 ’(uuid-bit-vector-32-length)) => T

(typep 31 ’(uuid-bit-vector-31-length)) => NIL

:SEE-ALSO ‘uuid-bit-vector-length’, ‘uuid-bit-vector-128-length’, ‘uuid-bit-vector-48-length’, ‘uuid-bit-vector-32-length’, ‘uuid-bit-vector-16-length’, ‘uuid-bit-vector-8-length’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-bit-vector-48 ()

An object of type (simple-bit-vector 48) capable of representing 48
bits of a ‘unique-universal-identifier’

Objects of this type have a length of type ‘uuid-bit-vector-48-length’, and may be used to represent the integer values of the slot ‘%uuid_node’ of class ‘unique-universal-identifier’.

:EXAMPLE

(typep (subseq (uuid-bit-vector-128-zeroed) 0 48) ’uuid-bit-vector-48)

(typep (uuid-bit-vector-128-zeroed) ’uuid-bit-vector-128)

:SEE-ALSO ‘uuid-bit-vector’, ‘uuid-bit-vector-128’, ‘uuid-bit-vector-48’, ‘uuid-bit-vector-32’, ‘uuid-bit-vector-16’, ‘uuid-bit-vector-8’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-bit-vector-48-length ()

An object of type (uuid-bit-vector-length 48).

Objects of this type correspond with the length of a simple-bit-vector of type ‘uuid-bit-vector-48’ which are used to represent the integer values of the slot ‘%uuid_node’ of class ‘unique-universal-identifier’.

:EXAMPLE

(typep 48 ’(uuid-bit-vector-48-length)) => T

(typep 47 ’(uuid-bit-vector-48-length)) => NIL

:SEE-ALSO ‘uuid-bit-vector-length’, ‘uuid-bit-vector-128-length’, ‘uuid-bit-vector-48-length’, ‘uuid-bit-vector-32-length’, ‘uuid-bit-vector-16-length’, ‘uuid-bit-vector-8-length’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-bit-vector-8 ()

An object of type (simple-bit-vector 128) capable of representing 8
bits of a ‘unique-universal-identifier’

Objects of this type have a length of type ‘uuid-bit-vector-8-length’, and may be used to represent an ‘uuid-ub8’ value of any sub-sequence of bits in a ‘uuid-bit-vector-128’ and specifically those integer values of the slots ‘%uuid_clock-seq-and-reserved’ and ‘%uuid_clock-seq-low’ of class ‘unique-universal-identifier’.

:EXAMPLE

(typep (subseq (uuid-bit-vector-128-zeroed) 0 8) ’uuid-bit-vector-8)

(typep (uuid-bit-vector-128-zeroed) ’uuid-bit-vector-128)

:SEE-ALSO ‘uuid-bit-vector’, ‘uuid-bit-vector-128’, ‘uuid-bit-vector-48’, ‘uuid-bit-vector-32’, ‘uuid-bit-vector-16’, ‘uuid-bit-vector-8’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-bit-vector-8-length ()

An object of type (uuid-bit-vector-length 8).

Objects of this type correspond with the length of a simple-bit-vector of type ‘uuid-bit-vector-8’ which are used to represent the integer values of the slots ‘%uuid_clock-seq-low’ and ‘%uuid_clock-seq-and-reserved’ of class ‘unique-universal-identifier’.

:EXAMPLE

(typep 8 ’(uuid-bit-vector-8-length)) => T

(typep 8 ’(uuid-bit-vector-8-length)) => NIL

:SEE-ALSO ‘uuid-bit-vector-length’, ‘uuid-bit-vector-128-length’, ‘uuid-bit-vector-48-length’, ‘uuid-bit-vector-32-length’, ‘uuid-bit-vector-16-length’, ‘uuid-bit-vector-8-length’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-bit-vector-index INDEX-RANGE
Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-bit-vector-length SIZE
Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-bit-vector-null ()

An object of type ‘unicly:uuid-bit-vector-128’ and satisfying ‘unicly:uuid-bit-vector-eql’.

:EXAMPLE

(typep (uuid-bit-vector-128-zeroed) ’uuid-bit-vector-null)

(typep (make-array 128 :element-type ’bit :initial-element 1) ’uuid-bit-vector-null)

(not (typep (uuid-byte-array-16-zeroed) ’uuid-bit-vector-null))

:SEE-ALSO ‘uuid-bit-vector-128’, ‘uuid-bit-vector-128-zeroed’, ‘uuid-byte-array-16-zeroed’, ‘uuid-byte-array-null’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-bit-vector-valid-bit-offset ()
Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-bit-vector-valid-bit-width ()
Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-bit-vector-valid-length ()
Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-byte-array &optional SIZE
Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-byte-array-16 ()

An object which has the type signature: (simple-array (unsigned-byte 8) (16))

:EXAMPLE

(typep (uuid-to-byte-array *uuid-namespace-dns*) ’uuid-byte-array-16)

:SEE-ALSO ‘uuid-hex-string-36’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-byte-array-20 ()

An object which has the type signature: (simple-array (unsigned-byte 8) (20))

:EXAMPLE

(typep (uuid-string-to-sha1-byte-array "bubba") ’uuid-byte-array-20)

:SEE-ALSO ‘uuid-hex-string-36’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-byte-array-null ()

An object of type ‘unicly:uuid-byte-array-16’ with each element ‘cl:zerop’.

:EXAMPLE

(typep (uuid-byte-array-16-zeroed) ’uuid-byte-array-null)

(typep (make-array 16 :element-type ’uuid-ub8 :initial-element 0) ’uuid-byte-array-null)

(not (typep (make-array 16 :element-type ’uuid-ub8 :initial-element 1) ’uuid-byte-array-null))

(not (typep (uuid-bit-vector-128-zeroed) ’uuid-byte-array-null))

:SEE-ALSO ‘uuid-byte-array-16-zeroed’, ‘uuid-byte-array-16-p’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-byte-string ()

An object of with type signature: (simple-array character (16))

:EXAMPLE

(typep (uuid-get-bytes (uuid-print-bytes nil *uuid-namespace-dns*)) ’uuid-byte-string)

:SEE-ALSO ‘uuid-byte-array-16’, ‘uuid-hex-string-36’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-hex-string-12 ()

An object of type ‘uuid-hex-string-length’ with length 12.

:EXAMPLE

(typep (svref #("e3115c49" "6e13" "4d21" "9a37" "a1af250a8f88") 4) ’uuid-hex-string-12)

:SEE-ALSO ‘uuid-hex-string-length’, ‘uuid-hex-string-12’, ‘uuid-hex-string-8’, ‘uuid-hex-string-4’, ‘uuid-hex-string-2’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-hex-string-2 ()

An object of type ‘uuid-hex-string-length’ with length

:EXAMPLE

(typep (subseq (svref #("e3115c49" "6e13" "4d21" "9a37" "a1af250a8f88") 3) 0 2) ’uuid-hex-string-2)

:SEE-ALSO ‘uuid-hex-string-length’, ‘uuid-hex-string-12’, ‘uuid-hex-string-8’, ‘uuid-hex-string-4’, ‘uuid-hex-string-2’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-hex-string-32 ()

An object with the type signature:

(array character (32))

And satisfies ‘mon:string-all-hex-char-p’.

:EXAMPLE

(typep (uuid-print-bytes nil *uuid-namespace-dns*) ’uuid-hex-string-32)

;; Following fails successfully:

(typep (print-object *uuid-namespace-dns* nil) ’uuid-hex-string-32)

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-hex-string-36 ()

An object of type (array character (36)) satsfying ‘uuid-hex-string-36-p’.

:EXAMPLE

(type

(typep "6ba7b810-9dad-11d1-80b4-00c04fd430c8" ’uuid-hex-string-36)

(typep "6BA7B810-9DAD-11D1-80B4-00C04FD430C8" ’uuid-hex-string-36-p)

;; Following fails successfully:

(typep "6BA7B810–9DAD-11D1-80B4-00C04FD430C8 ’uuid-hex-string-36-p)

:SEE-ALSO ‘<XREF>’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-hex-string-4 ()

An object of type ‘uuid-hex-string-length’ with length 4.

:EXAMPLE

(typep (svref #("e3115c49" "6e13" "4d21" "9a37" "a1af250a8f88") 1) ’uuid-hex-string-4)

:SEE-ALSO ‘uuid-hex-string-length’, ‘uuid-hex-string-12’, ‘uuid-hex-string-8’, ‘uuid-hex-string-4’, ‘uuid-hex-string-2’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-hex-string-8 ()

An object of type ‘uuid-hex-string-length’ with length 8.

:EXAMPLE

(typep (svref #("e3115c49" "6e13" "4d21" "9a37" "a1af250a8f88") 0) ’uuid-hex-string-8)

:SEE-ALSO ‘uuid-hex-string-length’, ‘uuid-hex-string-12’, ‘uuid-hex-string-8’, ‘uuid-hex-string-4’, ‘uuid-hex-string-2’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-hex-string-length STRING-LENGTH
Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-simple-string-vector-5 ()
Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-simple-vector-5 ()

Objects of this type are passed as the cl:nth-value 1 by funcitions which frob objects of type ‘uuid-hex-string-36’.

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘uuid-delimited-string-36-p’, ‘uuid-hex-string-36-p’, ‘%uuid-hex-string-36-null-string-p’,
‘make-uuid-from-string-if’, ‘make-uuid-from-string’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-string-32 ()

An object with the type signature: (array character (36))

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘uuid-byte-string’, ‘uuid-byte-array-16’, ‘uuid-string-32’, ‘uuid-string-36’, ‘uuid-hex-string-32’, ‘uuid-hex-string-36’, ‘uuid-hex-string-32-p’, ‘uuid-hex-string-36-p’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-string-36 ()

An object with the type signature: (array character (32)) :EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘uuid-byte-string’, ‘uuid-byte-array-16’, ‘uuid-string-32’, ‘uuid-string-36’, ‘uuid-hex-string-32’, ‘uuid-hex-string-36’, ‘uuid-hex-string-32-p’, ‘uuid-hex-string-36-p’,.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-ub128 ()

An object of type: (unsigned-byte 128)

Octets: 16
Bits: 128
Hex value: #xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Decimal value: 340282366920938463463374607431768211455
Octal value: #o3777777777777777777777777777777777777777777

An object of this type is capable of representing the combined the integer value of the slots of class ‘unique-universal-identifier’.

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO
‘uuid-unsigned-byte-size’, ‘uuid-ub128’, ‘uuid-ub64’, ‘uuid-ub48’, ‘uuid-ub32’, ‘uuid-ub16’, ‘uuid-ub8’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-ub128-integer-length ()
Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-ub16 ()

An object of type: (unsigned-byte 16)

Octets: 2
Bits: 16
Hex value: #xFFFF
Decimal value: 65535
Octal value: #o177777
Binary value: #b1111111111111111

Capable of representing the integer value of slots ‘%uuid_time-mid’ and ‘%uuid_time-high-and-version’ of class ‘unique-universal-identifier’.

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘uuid-unsigned-byte-size’, ‘uuid-ub128’, ‘uuid-ub64’, ‘uuid-ub48’, ‘uuid-ub32’, ‘uuid-ub16’, ‘uuid-ub8’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-ub24 ()
Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-ub25-integer-length ()
Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-ub32 ()

An object of type: (unsigned-byte 32)

Octets: 4
Bits: 32
Hex value: #xFFFFFFFF
Decimal value: 4294967295
Octal value: #o37777777777
Binary value: #b11111111111111111111111111111111

Capable of representing the integer value of slot ‘%uuid_time-low’ of class ‘unique-universal-identifier’.

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘uuid-unsigned-byte-size’, ‘uuid-ub128’, ‘uuid-ub64’, ‘uuid-ub48’, ‘uuid-ub32’, ‘uuid-ub16’, ‘uuid-ub8’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-ub33-integer-length ()
Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-ub48 ()

An object of type: (unsigned-byte 48)

Octets: 6
Bits: 48
Hex value: #xFFFFFFFFFFFF
Decimal value: 281474976710655
Octal value: #o7777777777777777
:Binary value: #b111111111111111111111111111111111111111111111111

Capable of representing the integer value of slot ‘%uuid_node’ of class ‘unique-universal-identifier’.

An object of this type is capable of representing any integer value
of a slot of class ‘unique-universal-identifier’.

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘uuid-unsigned-byte-size’, ‘uuid-ub128’, ‘uuid-ub64’, ‘uuid-ub48’, ‘uuid-ub32’, ‘uuid-ub16’, ‘uuid-ub8’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-ub49-integer-length ()
Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-ub64 ()

An object of type: (unsigned-byte 64)

An object of this type is capable of representing any integer value
of a slot of class ‘unique-universal-identifier’.

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘uuid-unsigned-byte-size’, ‘uuid-ub128’, ‘uuid-ub64’, ‘uuid-ub48’, ‘uuid-ub32’, ‘uuid-ub16’, ‘uuid-ub8’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-ub64-integer-length ()
Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-ub8 ()

An object of type: (unsigned-byte 8)

Octets: 1
Bits: 8
Hex value: #xFF
Decimal value: 255
Octal value: #o377
Binary value: #b11111111

Capable of representing integer of any any element in an object of type ‘uuid-byte-array’ and the and the integer value of slots ‘%uuid_clock-seq-and-reserved’ ‘%uuid_clock-seq-low’ of class ‘unique-universal-identifier’.

:EXAMPLE

{ ... <EXAMPLE> ... }

:SEE-ALSO ‘uuid-unsigned-byte-size’, ‘uuid-ub128’, ‘uuid-ub64’, ‘uuid-ub48’, ‘uuid-ub32’, ‘uuid-ub16’, ‘uuid-ub8’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-ub9-integer-length ()
Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-unsigned-byte-integer-length INTEGER
Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-unsigned-byte-size BYTE-SIZE
Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-v3-4-or-5-int ()

An integer value in the range [3,5].

Range represents the possible return values for ‘unicly:uuid-version-uuid’ when
an object is a UUID as per return value of:

‘make-v3-uuid’ ‘make-v4-uuid’ ‘make-v5-uuid’

:EXAMPLE

(equal (subseq (mapcar #’(lambda (x) (typep x ’uuid-v3-4-or-5-int))
(loop for x from 2 below 7 collect x))
1 4)
(list T T T))

(equal (mapcar #’(lambda (x) (typep (uuid-version-uuid x) ’uuid-v3-4-or-5-int))
(list (make-v3-uuid *uuid-namespace-dns* "bubba") (make-v4-uuid)
(make-v5-uuid *uuid-namespace-dns* "bubba")))
(list T T T))

:SEE-ALSO ‘unicly::uuid-version-int’, ‘unicly::uuid-v3-or-5-int’, ‘unicly::uuid-version-bit-vector’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-v3-or-5-int ()

An integer value either 3 or 5.

Range represents the possible return values for ‘unicly:uuid-version-uuid’ when
an object is a UUID as per return value of:

‘make-v3-uuid’ ‘make-v5-uuid’

:EXAMPLE

(equal (subseq (mapcar #’(lambda (x) (typep x ’uuid-v3-or-5-int))
(loop for x from 2 below 7 collect x))
1 4)
(list T NIL T))

(equal (mapcar #’(lambda (x) (typep (uuid-version-uuid x) ’uuid-v3-or-5-int))
(list (make-v3-uuid *uuid-namespace-dns* "bubba") (make-v4-uuid)
(make-v5-uuid *uuid-namespace-dns* "bubba")))
(list T NIL T))

:SEE-ALSO ‘unicly::uuid-version-int’, ‘unicly::uuid-v3-4-or-5-int’, ‘unicly::uuid-version-bit-vector’.

Package

unicly

Source

unicly-types.lisp (file)

Type: uuid-version-int ()

An integer value in the range [0,5].

Range represents the possible return values for ‘unicly:uuid-version-uuid’ when
an object is a UUID as per return value of:

‘unicly:make-v3-uuid’, ‘unicly:make-v4-uuid’, ‘unicly:make-v5-uuid’

and exclusive of return value for ‘unicly:make-null-uuid’.

:EXAMPLE

(loop
for x from 0 below 6
for y = (typep x ’uuid-version-int)
always y)

:SEE-ALSO ‘unicly::uuid-v3-or-5-int’, ‘unicly::uuid-v3-4-or-5-int’, ‘unicly::uuid-version-bit-vector’.

Package

unicly

Source

unicly-types.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   U  
Index Entry  Section

F
File, Lisp, unicly.asd: The unicly<dot>asd file
File, Lisp, unicly/package.lisp: The unicly/package<dot>lisp file
File, Lisp, unicly/unicly-bit-vectors.lisp: The unicly/unicly-bit-vectors<dot>lisp file
File, Lisp, unicly/unicly-bridge.lisp: The unicly/unicly-bridge<dot>lisp file
File, Lisp, unicly/unicly-byte-arrays.lisp: The unicly/unicly-byte-arrays<dot>lisp file
File, Lisp, unicly/unicly-class.lisp: The unicly/unicly-class<dot>lisp file
File, Lisp, unicly/unicly-conditions.lisp: The unicly/unicly-conditions<dot>lisp file
File, Lisp, unicly/unicly-docs.lisp: The unicly/unicly-docs<dot>lisp file
File, Lisp, unicly/unicly-extend.lisp: The unicly/unicly-extend<dot>lisp file
File, Lisp, unicly/unicly-hash-table.lisp: The unicly/unicly-hash-table<dot>lisp file
File, Lisp, unicly/unicly-integers.lisp: The unicly/unicly-integers<dot>lisp file
File, Lisp, unicly/unicly-io.lisp: The unicly/unicly-io<dot>lisp file
File, Lisp, unicly/unicly-macros.lisp: The unicly/unicly-macros<dot>lisp file
File, Lisp, unicly/unicly-null-check.lisp: The unicly/unicly-null-check<dot>lisp file
File, Lisp, unicly/unicly-specials.lisp: The unicly/unicly-specials<dot>lisp file
File, Lisp, unicly/unicly-string-uuid.lisp: The unicly/unicly-string-uuid<dot>lisp file
File, Lisp, unicly/unicly-types.lisp: The unicly/unicly-types<dot>lisp file
File, Lisp, unicly/unicly-utils.lisp: The unicly/unicly-utils<dot>lisp file
File, Lisp, unicly/unicly-uuid-version.lisp: The unicly/unicly-uuid-version<dot>lisp file
File, Lisp, unicly/unicly.lisp: The unicly/unicly<dot>lisp file

L
Lisp File, unicly.asd: The unicly<dot>asd file
Lisp File, unicly/package.lisp: The unicly/package<dot>lisp file
Lisp File, unicly/unicly-bit-vectors.lisp: The unicly/unicly-bit-vectors<dot>lisp file
Lisp File, unicly/unicly-bridge.lisp: The unicly/unicly-bridge<dot>lisp file
Lisp File, unicly/unicly-byte-arrays.lisp: The unicly/unicly-byte-arrays<dot>lisp file
Lisp File, unicly/unicly-class.lisp: The unicly/unicly-class<dot>lisp file
Lisp File, unicly/unicly-conditions.lisp: The unicly/unicly-conditions<dot>lisp file
Lisp File, unicly/unicly-docs.lisp: The unicly/unicly-docs<dot>lisp file
Lisp File, unicly/unicly-extend.lisp: The unicly/unicly-extend<dot>lisp file
Lisp File, unicly/unicly-hash-table.lisp: The unicly/unicly-hash-table<dot>lisp file
Lisp File, unicly/unicly-integers.lisp: The unicly/unicly-integers<dot>lisp file
Lisp File, unicly/unicly-io.lisp: The unicly/unicly-io<dot>lisp file
Lisp File, unicly/unicly-macros.lisp: The unicly/unicly-macros<dot>lisp file
Lisp File, unicly/unicly-null-check.lisp: The unicly/unicly-null-check<dot>lisp file
Lisp File, unicly/unicly-specials.lisp: The unicly/unicly-specials<dot>lisp file
Lisp File, unicly/unicly-string-uuid.lisp: The unicly/unicly-string-uuid<dot>lisp file
Lisp File, unicly/unicly-types.lisp: The unicly/unicly-types<dot>lisp file
Lisp File, unicly/unicly-utils.lisp: The unicly/unicly-utils<dot>lisp file
Lisp File, unicly/unicly-uuid-version.lisp: The unicly/unicly-uuid-version<dot>lisp file
Lisp File, unicly/unicly.lisp: The unicly/unicly<dot>lisp file

U
unicly.asd: The unicly<dot>asd file
unicly/package.lisp: The unicly/package<dot>lisp file
unicly/unicly-bit-vectors.lisp: The unicly/unicly-bit-vectors<dot>lisp file
unicly/unicly-bridge.lisp: The unicly/unicly-bridge<dot>lisp file
unicly/unicly-byte-arrays.lisp: The unicly/unicly-byte-arrays<dot>lisp file
unicly/unicly-class.lisp: The unicly/unicly-class<dot>lisp file
unicly/unicly-conditions.lisp: The unicly/unicly-conditions<dot>lisp file
unicly/unicly-docs.lisp: The unicly/unicly-docs<dot>lisp file
unicly/unicly-extend.lisp: The unicly/unicly-extend<dot>lisp file
unicly/unicly-hash-table.lisp: The unicly/unicly-hash-table<dot>lisp file
unicly/unicly-integers.lisp: The unicly/unicly-integers<dot>lisp file
unicly/unicly-io.lisp: The unicly/unicly-io<dot>lisp file
unicly/unicly-macros.lisp: The unicly/unicly-macros<dot>lisp file
unicly/unicly-null-check.lisp: The unicly/unicly-null-check<dot>lisp file
unicly/unicly-specials.lisp: The unicly/unicly-specials<dot>lisp file
unicly/unicly-string-uuid.lisp: The unicly/unicly-string-uuid<dot>lisp file
unicly/unicly-types.lisp: The unicly/unicly-types<dot>lisp file
unicly/unicly-utils.lisp: The unicly/unicly-utils<dot>lisp file
unicly/unicly-uuid-version.lisp: The unicly/unicly-uuid-version<dot>lisp file
unicly/unicly.lisp: The unicly/unicly<dot>lisp file

Jump to:   F   L   U  

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

A.2 Functions

Jump to:   %  
C   D   F   G   H   M   S   T   U   V  
Index Entry  Section

%
%def-uuid-format-and-intern-symbol: Internal functions
%def-uuid-format-and-intern-symbol-type-checker: Internal functions
%def-uuid-format-and-intern-symbol-type-predicate: Internal functions
%lw-string-zerop: Internal functions
%make-null-uuid-loadtime: Internal functions
%make-uuid-from-bit-vector-extendable-bv-zeroed-error: Internal functions
%make-uuid-from-byte-array-extended-null-array-error: Internal functions
%make-uuid-from-string-extended-null-string-error: Internal functions
%string-not-empty-p: Internal functions
%unique-universal-identifier-null-p: Internal functions
%uuid-bit-vector-null-p: Internal functions
%uuid-byte-array-null-p: Internal functions
%uuid-digest-uuid-instance-md5: Internal functions
%uuid-digest-uuid-instance-sha1: Internal functions
%uuid-hex-string-36-null-string-p: Internal functions
%uuid-octets-to-string: Internal functions
%uuid-string-to-octets: Internal functions
%uuid-uuid-version-if: Internal functions
%uuid-version-bit-vector-if: Internal functions
%uuid_byte-array-16-ub8-reqeust: Internal functions
%uuid_clock-seq-and-reserved-request: Internal functions
%uuid_clock-seq-and-reserved-request-bit-vector: Internal functions
%uuid_clock-seq-low-request: Internal functions
%uuid_clock-seq-low-request-bit-vector: Internal functions
%uuid_node-request: Internal functions
%uuid_node-request-bit-vector: Internal functions
%uuid_time-high-and-version-request: Internal functions
%uuid_time-high-and-version-request-bit-vector: Internal functions
%uuid_time-low-request: Internal functions
%uuid_time-low-request-bit-vector: Internal functions
%uuid_time-mid-request: Internal functions
%uuid_time-mid-request-bit-vector: Internal functions
%verify-digest-version: Internal functions
%verify-non-empty-name-arg: Internal functions
%verify-non-null-namespace-arg: Internal functions
%verify-slot-boundp-and-type: Internal functions
%verify-valid-subclass-and-slots: Internal functions
%verify-valid-uuid-subclass-slots: Internal functions
%verify-valid-uuid-subclass-type: Internal functions
%verify-version-3-or-5: Internal functions

C
Compiler Macro, uuid-request-integer: Internal compiler macros

D
def-indexed-hexstring-integer-parser: Internal macros
def-make-uuid-byte-array-extended: Internal macros
def-make-uuid-extend-class-fun: Internal macros
def-make-uuid-from-string-extended: Internal macros
def-make-v3-uuid-extended: Internal macros
def-make-v4-uuid-extended: Internal macros
def-make-v5-uuid-extended: Internal macros
def-uuid-bit-vector-length-type: Internal macros
def-uuid-bit-vector-n-type: Internal macros
def-uuid-bit-vector-zeroed: Internal macros
def-uuid-byte-array-length: Internal macros
def-uuid-from-bit-vector-extendable: Internal macros
def-uuid-predicate-and-type-check-definer: Internal macros
def-uuid-request-integer-bit-vector: Internal macros
def-uuid-type-check-definer: Internal macros
def-uuid-type-definer: Internal macros
def-uuid-type-predicate-definer: Internal macros
def-uuid-unsigned-byte-integer-length: Internal macros
def-uuid-unsigned-byte-size: Internal macros
def-uuid-uuid-hex-string-length: Internal macros
defconst: Internal macros
digested-v3-uuid: Internal functions
digested-v3or5-uuid: Internal functions
digested-v5-uuid: Internal functions
doc-set: Internal functions

F
Function, %def-uuid-format-and-intern-symbol: Internal functions
Function, %def-uuid-format-and-intern-symbol-type-checker: Internal functions
Function, %def-uuid-format-and-intern-symbol-type-predicate: Internal functions
Function, %lw-string-zerop: Internal functions
Function, %make-null-uuid-loadtime: Internal functions
Function, %make-uuid-from-bit-vector-extendable-bv-zeroed-error: Internal functions
Function, %make-uuid-from-byte-array-extended-null-array-error: Internal functions
Function, %make-uuid-from-string-extended-null-string-error: Internal functions
Function, %string-not-empty-p: Internal functions
Function, %unique-universal-identifier-null-p: Internal functions
Function, %uuid-bit-vector-null-p: Internal functions
Function, %uuid-byte-array-null-p: Internal functions
Function, %uuid-digest-uuid-instance-md5: Internal functions
Function, %uuid-digest-uuid-instance-sha1: Internal functions
Function, %uuid-hex-string-36-null-string-p: Internal functions
Function, %uuid-octets-to-string: Internal functions
Function, %uuid-string-to-octets: Internal functions
Function, %uuid-uuid-version-if: Internal functions
Function, %uuid-version-bit-vector-if: Internal functions
Function, %uuid_byte-array-16-ub8-reqeust: Internal functions
Function, %uuid_clock-seq-and-reserved-request: Internal functions
Function, %uuid_clock-seq-and-reserved-request-bit-vector: Internal functions
Function, %uuid_clock-seq-low-request: Internal functions
Function, %uuid_clock-seq-low-request-bit-vector: Internal functions
Function, %uuid_node-request: Internal functions
Function, %uuid_node-request-bit-vector: Internal functions
Function, %uuid_time-high-and-version-request: Internal functions
Function, %uuid_time-high-and-version-request-bit-vector: Internal functions
Function, %uuid_time-low-request: Internal functions
Function, %uuid_time-low-request-bit-vector: Internal functions
Function, %uuid_time-mid-request: Internal functions
Function, %uuid_time-mid-request-bit-vector: Internal functions
Function, %verify-digest-version: Internal functions
Function, %verify-non-empty-name-arg: Internal functions
Function, %verify-non-null-namespace-arg: Internal functions
Function, %verify-slot-boundp-and-type: Internal functions
Function, %verify-valid-subclass-and-slots: Internal functions
Function, %verify-valid-uuid-subclass-slots: Internal functions
Function, %verify-valid-uuid-subclass-type: Internal functions
Function, %verify-version-3-or-5: Internal functions
Function, digested-v3-uuid: Internal functions
Function, digested-v3or5-uuid: Internal functions
Function, digested-v5-uuid: Internal functions
Function, doc-set: Internal functions
Function, fundoc: Internal functions
Function, generic-doc: Internal functions
Function, hexadecimal-char-p: Internal functions
Function, make-hash-table-uuid: Exported functions
Function, make-null-uuid: Exported functions
Function, make-uuid-from-string: Exported functions
Function, make-uuid-from-string-if: Internal functions
Function, make-v3-uuid: Exported functions
Function, make-v4-uuid: Exported functions
Function, make-v5-uuid: Exported functions
Function, method-doc: Internal functions
Function, simple-string-compat-p: Internal functions
Function, string-all-hex-char-p: Internal functions
Function, string-not-null-or-empty-p: Internal functions
Function, string-with-fill-pointer-check-type: Internal functions
Function, string-with-fill-pointer-p: Internal functions
Function, sxhash-uuid: Exported functions
Function, type-specifier-p: Internal functions
Function, typedoc: Internal functions
Function, unique-universal-identifier-null-p: Exported functions
Function, uuid-as-urn-string: Exported functions
Function, uuid-assemble-ub16: Internal functions
Function, uuid-assemble-ub32: Internal functions
Function, uuid-assemble-ub48: Internal functions
Function, uuid-bit-vector-128-check-type: Internal functions
Function, uuid-bit-vector-128-p: Exported functions
Function, uuid-bit-vector-128-zeroed: Internal functions
Function, uuid-bit-vector-16-check-type: Internal functions
Function, uuid-bit-vector-16-p: Internal functions
Function, uuid-bit-vector-16-zeroed: Internal functions
Function, uuid-bit-vector-32-check-type: Internal functions
Function, uuid-bit-vector-32-p: Internal functions
Function, uuid-bit-vector-32-zeroed: Internal functions
Function, uuid-bit-vector-48-check-type: Internal functions
Function, uuid-bit-vector-48-p: Internal functions
Function, uuid-bit-vector-48-zeroed: Internal functions
Function, uuid-bit-vector-8-zeroed: Internal functions
Function, uuid-bit-vector-build-offsets: Internal functions
Function, uuid-bit-vector-eql: Exported functions
Function, uuid-bit-vector-null-p: Exported functions
Function, uuid-bit-vector-to-byte-array: Exported functions
Function, uuid-bit-vector-to-integer: Internal functions
Function, uuid-bit-vector-v3-p: Exported functions
Function, uuid-bit-vector-v4-p: Exported functions
Function, uuid-bit-vector-v5-p: Exported functions
Function, uuid-byte-array-16-check-type: Internal functions
Function, uuid-byte-array-16-p: Exported functions
Function, uuid-byte-array-16-to-integer: Exported functions
Function, uuid-byte-array-16-zeroed: Exported functions
Function, uuid-byte-array-20-check-type: Internal functions
Function, uuid-byte-array-20-p: Internal functions
Function, uuid-byte-array-check-type: Internal functions
Function, uuid-byte-array-null-p: Exported functions
Function, uuid-byte-array-p: Internal functions
Function, uuid-byte-array-to-bit-vector: Exported functions
Function, uuid-byte-string-check-type: Internal functions
Function, uuid-byte-string-p: Exported functions
Function, uuid-copy-uuid: Exported functions
Function, uuid-delimited-string-36-p: Internal functions
Function, uuid-deposit-octet-to-bit-vector: Internal functions
Function, uuid-deserialize-bit-vector-bits: Internal functions
Function, uuid-deserialize-byte-array-bytes: Internal functions
Function, uuid-digest-uuid-instance: Internal functions
Function, uuid-disassemble-ub16: Internal functions
Function, uuid-disassemble-ub32: Internal functions
Function, uuid-disassemble-ub48: Internal functions
Function, uuid-from-bit-vector: Exported functions
Function, uuid-from-byte-array: Exported functions
Function, uuid-get-namespace-bytes: Exported functions
Function, uuid-hex-string-32-p: Exported functions
Function, uuid-hex-string-36-p: Exported functions
Function, uuid-hex-vector-parse-clock-seq-and-reserved: Internal functions
Function, uuid-hex-vector-parse-clock-seq-low: Internal functions
Function, uuid-hex-vector-parse-node: Internal functions
Function, uuid-hex-vector-parse-time-high-and-version: Internal functions
Function, uuid-hex-vector-parse-time-low: Internal functions
Function, uuid-hex-vector-parse-time-mid: Internal functions
Function, uuid-integer-128-to-bit-vector: Internal functions
Function, uuid-integer-128-to-byte-array: Internal functions
Function, uuid-octet-to-bit-vector-8: Internal functions
Function, uuid-read-bit-vector-bits: Internal functions
Function, uuid-request-integer: Internal functions
Function, uuid-serialize-bit-vector-bits: Internal functions
Function, uuid-serialize-byte-array-bytes: Internal functions
Function, uuid-simple-type-error: Internal functions
Function, uuid-simple-vector-5-check-type: Internal functions
Function, uuid-simple-vector-5-p: Internal functions
Function, uuid-string-32-check-type: Internal functions
Function, uuid-string-32-p: Exported functions
Function, uuid-string-36-check-type: Internal functions
Function, uuid-string-36-p: Exported functions
Function, uuid-to-bit-vector: Exported functions
Function, uuid-to-byte-array: Internal functions
Function, uuid-valid-stream-p: Internal functions
Function, uuid-valid-stream-verify-for-input: Internal functions
Function, uuid-valid-stream-verify-for-output: Internal functions
Function, uuid-valid-stream-verify-io-octet-type: Internal functions
Function, uuid-valid-stream-verify-io-type: Internal functions
Function, uuid-valid-stream-verify-octet-stream-for-input: Internal functions
Function, uuid-valid-stream-verify-octet-stream-for-output: Internal functions
Function, uuid-verify-bit-vector-simplicity: Internal functions
Function, uuid-version-bit-vector: Internal functions
Function, uuid-version-uuid: Exported functions
Function, vardoc: Internal functions
Function, vector-with-fill-pointer-p: Internal functions
Function, verify-sane-namespace-and-name: Internal functions
fundoc: Internal functions

G
Generic Function, unique-universal-identifier-p: Exported generic functions
Generic Function, uuid-bit-48-error-datum: Internal generic functions
Generic Function, uuid-bit-48-error-expected-type: Internal generic functions
Generic Function, uuid-eql: Exported generic functions
Generic Function, uuid-princ-to-string: Exported generic functions
Generic Function, uuid-print-bit-vector: Exported generic functions
Generic Function, uuid-print-bytes: Internal generic functions
Generic Function, uuid-print-bytes-to-string: Exported generic functions
Generic Function, uuid-slot-unbound-name: Internal generic functions
Generic Function, uuid-slot-unbound-object: Internal generic functions
generic-doc: Internal functions

H
hexadecimal-char-p: Internal functions

M
Macro, def-indexed-hexstring-integer-parser: Internal macros
Macro, def-make-uuid-byte-array-extended: Internal macros
Macro, def-make-uuid-extend-class-fun: Internal macros
Macro, def-make-uuid-from-string-extended: Internal macros
Macro, def-make-v3-uuid-extended: Internal macros
Macro, def-make-v4-uuid-extended: Internal macros
Macro, def-make-v5-uuid-extended: Internal macros
Macro, def-uuid-bit-vector-length-type: Internal macros
Macro, def-uuid-bit-vector-n-type: Internal macros
Macro, def-uuid-bit-vector-zeroed: Internal macros
Macro, def-uuid-byte-array-length: Internal macros
Macro, def-uuid-from-bit-vector-extendable: Internal macros
Macro, def-uuid-predicate-and-type-check-definer: Internal macros
Macro, def-uuid-request-integer-bit-vector: Internal macros
Macro, def-uuid-type-check-definer: Internal macros
Macro, def-uuid-type-definer: Internal macros
Macro, def-uuid-type-predicate-definer: Internal macros
Macro, def-uuid-unsigned-byte-integer-length: Internal macros
Macro, def-uuid-unsigned-byte-size: Internal macros
Macro, def-uuid-uuid-hex-string-length: Internal macros
Macro, defconst: Internal macros
Macro, uuid-string-parse-integer: Internal macros
Macro, uuid-svref-for-parse-integer: Internal macros
make-hash-table-uuid: Exported functions
make-null-uuid: Exported functions
make-uuid-from-string: Exported functions
make-uuid-from-string-if: Internal functions
make-v3-uuid: Exported functions
make-v4-uuid: Exported functions
make-v5-uuid: Exported functions
Method, unique-universal-identifier-p: Exported generic functions
Method, unique-universal-identifier-p: Exported generic functions
Method, unique-universal-identifier-p: Exported generic functions
Method, uuid-bit-48-error-datum: Internal generic functions
Method, uuid-bit-48-error-expected-type: Internal generic functions
Method, uuid-eql: Exported generic functions
Method, uuid-eql: Exported generic functions
Method, uuid-eql: Exported generic functions
Method, uuid-eql: Exported generic functions
Method, uuid-eql: Exported generic functions
Method, uuid-eql: Exported generic functions
Method, uuid-eql: Exported generic functions
Method, uuid-eql: Exported generic functions
Method, uuid-eql: Exported generic functions
Method, uuid-eql: Exported generic functions
Method, uuid-eql: Exported generic functions
Method, uuid-eql: Exported generic functions
Method, uuid-eql: Exported generic functions
Method, uuid-eql: Exported generic functions
Method, uuid-eql: Exported generic functions
Method, uuid-eql: Exported generic functions
Method, uuid-eql: Exported generic functions
Method, uuid-princ-to-string: Exported generic functions
Method, uuid-print-bit-vector: Exported generic functions
Method, uuid-print-bit-vector: Exported generic functions
Method, uuid-print-bit-vector: Exported generic functions
Method, uuid-print-bytes: Internal generic functions
Method, uuid-print-bytes-to-string: Exported generic functions
Method, uuid-print-bytes-to-string: Exported generic functions
Method, uuid-slot-unbound-name: Internal generic functions
Method, uuid-slot-unbound-object: Internal generic functions
method-doc: Internal functions

S
simple-string-compat-p: Internal functions
string-all-hex-char-p: Internal functions
string-not-null-or-empty-p: Internal functions
string-with-fill-pointer-check-type: Internal functions
string-with-fill-pointer-p: Internal functions
sxhash-uuid: Exported functions

T
type-specifier-p: Internal functions
typedoc: Internal functions

U
unique-universal-identifier-null-p: Exported functions
unique-universal-identifier-p: Exported generic functions
unique-universal-identifier-p: Exported generic functions
unique-universal-identifier-p: Exported generic functions
unique-universal-identifier-p: Exported generic functions
uuid-as-urn-string: Exported functions
uuid-assemble-ub16: Internal functions
uuid-assemble-ub32: Internal functions
uuid-assemble-ub48: Internal functions
uuid-bit-48-error-datum: Internal generic functions
uuid-bit-48-error-datum: Internal generic functions
uuid-bit-48-error-expected-type: Internal generic functions
uuid-bit-48-error-expected-type: Internal generic functions
uuid-bit-vector-128-check-type: Internal functions
uuid-bit-vector-128-p: Exported functions
uuid-bit-vector-128-zeroed: Internal functions
uuid-bit-vector-16-check-type: Internal functions
uuid-bit-vector-16-p: Internal functions
uuid-bit-vector-16-zeroed: Internal functions
uuid-bit-vector-32-check-type: Internal functions
uuid-bit-vector-32-p: Internal functions
uuid-bit-vector-32-zeroed: Internal functions
uuid-bit-vector-48-check-type: Internal functions
uuid-bit-vector-48-p: Internal functions
uuid-bit-vector-48-zeroed: Internal functions
uuid-bit-vector-8-zeroed: Internal functions
uuid-bit-vector-build-offsets: Internal functions
uuid-bit-vector-eql: Exported functions
uuid-bit-vector-null-p: Exported functions
uuid-bit-vector-to-byte-array: Exported functions
uuid-bit-vector-to-integer: Internal functions
uuid-bit-vector-v3-p: Exported functions
uuid-bit-vector-v4-p: Exported functions
uuid-bit-vector-v5-p: Exported functions
uuid-byte-array-16-check-type: Internal functions
uuid-byte-array-16-p: Exported functions
uuid-byte-array-16-to-integer: Exported functions
uuid-byte-array-16-zeroed: Exported functions
uuid-byte-array-20-check-type: Internal functions
uuid-byte-array-20-p: Internal functions
uuid-byte-array-check-type: Internal functions
uuid-byte-array-null-p: Exported functions
uuid-byte-array-p: Internal functions
uuid-byte-array-to-bit-vector: Exported functions
uuid-byte-string-check-type: Internal functions
uuid-byte-string-p: Exported functions
uuid-copy-uuid: Exported functions
uuid-delimited-string-36-p: Internal functions
uuid-deposit-octet-to-bit-vector: Internal functions
uuid-deserialize-bit-vector-bits: Internal functions
uuid-deserialize-byte-array-bytes: Internal functions
uuid-digest-uuid-instance: Internal functions
uuid-disassemble-ub16: Internal functions
uuid-disassemble-ub32: Internal functions
uuid-disassemble-ub48: Internal functions
uuid-eql: Exported generic functions
uuid-eql: Exported generic functions
uuid-eql: Exported generic functions
uuid-eql: Exported generic functions
uuid-eql: Exported generic functions
uuid-eql: Exported generic functions
uuid-eql: Exported generic functions
uuid-eql: Exported generic functions
uuid-eql: Exported generic functions
uuid-eql: Exported generic functions
uuid-eql: Exported generic functions
uuid-eql: Exported generic functions
uuid-eql: Exported generic functions
uuid-eql: Exported generic functions
uuid-eql: Exported generic functions
uuid-eql: Exported generic functions
uuid-eql: Exported generic functions
uuid-eql: Exported generic functions
uuid-from-bit-vector: Exported functions
uuid-from-byte-array: Exported functions
uuid-get-namespace-bytes: Exported functions
uuid-hex-string-32-p: Exported functions
uuid-hex-string-36-p: Exported functions
uuid-hex-vector-parse-clock-seq-and-reserved: Internal functions
uuid-hex-vector-parse-clock-seq-low: Internal functions
uuid-hex-vector-parse-node: Internal functions
uuid-hex-vector-parse-time-high-and-version: Internal functions
uuid-hex-vector-parse-time-low: Internal functions
uuid-hex-vector-parse-time-mid: Internal functions
uuid-integer-128-to-bit-vector: Internal functions
uuid-integer-128-to-byte-array: Internal functions
uuid-octet-to-bit-vector-8: Internal functions
uuid-princ-to-string: Exported generic functions
uuid-princ-to-string: Exported generic functions
uuid-print-bit-vector: Exported generic functions
uuid-print-bit-vector: Exported generic functions
uuid-print-bit-vector: Exported generic functions
uuid-print-bit-vector: Exported generic functions
uuid-print-bytes: Internal generic functions
uuid-print-bytes: Internal generic functions
uuid-print-bytes-to-string: Exported generic functions
uuid-print-bytes-to-string: Exported generic functions
uuid-print-bytes-to-string: Exported generic functions
uuid-read-bit-vector-bits: Internal functions
uuid-request-integer: Internal compiler macros
uuid-request-integer: Internal functions
uuid-serialize-bit-vector-bits: Internal functions
uuid-serialize-byte-array-bytes: Internal functions
uuid-simple-type-error: Internal functions
uuid-simple-vector-5-check-type: Internal functions
uuid-simple-vector-5-p: Internal functions
uuid-slot-unbound-name: Internal generic functions
uuid-slot-unbound-name: Internal generic functions
uuid-slot-unbound-object: Internal generic functions
uuid-slot-unbound-object: Internal generic functions
uuid-string-32-check-type: Internal functions
uuid-string-32-p: Exported functions
uuid-string-36-check-type: Internal functions
uuid-string-36-p: Exported functions
uuid-string-parse-integer: Internal macros
uuid-svref-for-parse-integer: Internal macros
uuid-to-bit-vector: Exported functions
uuid-to-byte-array: Internal functions
uuid-valid-stream-p: Internal functions
uuid-valid-stream-verify-for-input: Internal functions
uuid-valid-stream-verify-for-output: Internal functions
uuid-valid-stream-verify-io-octet-type: Internal functions
uuid-valid-stream-verify-io-type: Internal functions
uuid-valid-stream-verify-octet-stream-for-input: Internal functions
uuid-valid-stream-verify-octet-stream-for-output: Internal functions
uuid-verify-bit-vector-simplicity: Internal functions
uuid-version-bit-vector: Internal functions
uuid-version-uuid: Exported functions

V
vardoc: Internal functions
vector-with-fill-pointer-p: Internal functions
verify-sane-namespace-and-name: Internal functions

Jump to:   %  
C   D   F   G   H   M   S   T   U   V  

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

A.3 Variables

Jump to:   %   *   +  
C   S   U  
Index Entry  Section

%
%uuid_clock-seq-and-reserved: Exported classes
%uuid_clock-seq-low: Exported classes
%uuid_node: Exported classes
%uuid_null: Internal classes
%uuid_time-high-and-version: Exported classes
%uuid_time-low: Exported classes
%uuid_time-mid: Exported classes

*
*author-maintainer-contact*: Internal special variables
*hexadecimal-chars*: Internal special variables
*random-state-uuid*: Internal special variables
*uuid-allow-empty-string-name-args*: Internal special variables
*uuid-allow-null-like-namespace-args*: Internal special variables
*uuid-namespace-dns*: Exported special variables
*uuid-namespace-oid*: Exported special variables
*uuid-namespace-url*: Exported special variables
*uuid-namespace-x500*: Exported special variables
*uuid-null-uuid*: Internal special variables

+
+%%uuid-sxhash-truncating-node%%+: Internal constants
+uuid-null-string+: Internal constants

C
Constant, +%%uuid-sxhash-truncating-node%%+: Internal constants
Constant, +uuid-null-string+: Internal constants

S
Slot, %uuid_clock-seq-and-reserved: Exported classes
Slot, %uuid_clock-seq-low: Exported classes
Slot, %uuid_node: Exported classes
Slot, %uuid_null: Internal classes
Slot, %uuid_time-high-and-version: Exported classes
Slot, %uuid_time-low: Exported classes
Slot, %uuid_time-mid: Exported classes
Slot, uuid-bit-48-error-datum: Internal conditions
Slot, uuid-bit-48-error-expected-type: Internal conditions
Slot, uuid-slot-unbound-name: Internal conditions
Slot, uuid-slot-unbound-object: Internal conditions
Special Variable, *author-maintainer-contact*: Internal special variables
Special Variable, *hexadecimal-chars*: Internal special variables
Special Variable, *random-state-uuid*: Internal special variables
Special Variable, *uuid-allow-empty-string-name-args*: Internal special variables
Special Variable, *uuid-allow-null-like-namespace-args*: Internal special variables
Special Variable, *uuid-namespace-dns*: Exported special variables
Special Variable, *uuid-namespace-oid*: Exported special variables
Special Variable, *uuid-namespace-url*: Exported special variables
Special Variable, *uuid-namespace-x500*: Exported special variables
Special Variable, *uuid-null-uuid*: Internal special variables

U
uuid-bit-48-error-datum: Internal conditions
uuid-bit-48-error-expected-type: Internal conditions
uuid-slot-unbound-name: Internal conditions
uuid-slot-unbound-object: Internal conditions

Jump to:   %   *   +  
C   S   U  

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

A.4 Data types

Jump to:   C   H   N   P   S   T   U  
Index Entry  Section

C
char-compat: Internal types
Class, unique-universal-identifier: Exported classes
Class, unique-universal-identifier-null: Internal classes
Condition, uuid-bit-48-error: Internal conditions
Condition, uuid-error: Internal conditions
Condition, uuid-simple-error: Internal conditions
Condition, uuid-simple-type-error: Internal conditions
Condition, uuid-slot-type-error: Internal conditions
Condition, uuid-slot-unbound-error: Internal conditions

H
hexadecimal-char: Internal types

N
not-null: Internal types

P
Package, unicly: The unicly package
Package, unicly-asd: The unicly-asd package

S
simple-string-compat: Internal types
simple-string-n-length-compat: Internal types
stream-or-boolean: Internal types
stream-or-boolean-or-string-with-fill-pointer: Internal types
string-compat: Internal types
string-empty: Internal types
string-n-length-compat: Internal types
string-not-empty: Internal types
string-not-null-or-empty: Internal types
string-or-null: Internal types
string-with-fill-pointer: Internal types
System, unicly: The unicly system

T
Type, char-compat: Internal types
Type, hexadecimal-char: Internal types
Type, not-null: Internal types
Type, simple-string-compat: Internal types
Type, simple-string-n-length-compat: Internal types
Type, stream-or-boolean: Internal types
Type, stream-or-boolean-or-string-with-fill-pointer: Internal types
Type, string-compat: Internal types
Type, string-empty: Internal types
Type, string-n-length-compat: Internal types
Type, string-not-empty: Internal types
Type, string-not-null-or-empty: Internal types
Type, string-or-null: Internal types
Type, string-with-fill-pointer: Internal types
Type, uuid-bit-vector: Internal types
Type, uuid-bit-vector-128: Internal types
Type, uuid-bit-vector-128-length: Internal types
Type, uuid-bit-vector-16: Internal types
Type, uuid-bit-vector-16-length: Internal types
Type, uuid-bit-vector-32: Internal types
Type, uuid-bit-vector-32-length: Internal types
Type, uuid-bit-vector-48: Internal types
Type, uuid-bit-vector-48-length: Internal types
Type, uuid-bit-vector-8: Internal types
Type, uuid-bit-vector-8-length: Internal types
Type, uuid-bit-vector-index: Internal types
Type, uuid-bit-vector-length: Internal types
Type, uuid-bit-vector-null: Internal types
Type, uuid-bit-vector-valid-bit-offset: Internal types
Type, uuid-bit-vector-valid-bit-width: Internal types
Type, uuid-bit-vector-valid-length: Internal types
Type, uuid-byte-array: Internal types
Type, uuid-byte-array-16: Internal types
Type, uuid-byte-array-20: Internal types
Type, uuid-byte-array-null: Internal types
Type, uuid-byte-string: Internal types
Type, uuid-hex-string-12: Internal types
Type, uuid-hex-string-2: Internal types
Type, uuid-hex-string-32: Internal types
Type, uuid-hex-string-36: Internal types
Type, uuid-hex-string-4: Internal types
Type, uuid-hex-string-8: Internal types
Type, uuid-hex-string-length: Internal types
Type, uuid-simple-string-vector-5: Internal types
Type, uuid-simple-vector-5: Internal types
Type, uuid-string-32: Internal types
Type, uuid-string-36: Internal types
Type, uuid-ub128: Internal types
Type, uuid-ub128-integer-length: Internal types
Type, uuid-ub16: Internal types
Type, uuid-ub24: Internal types
Type, uuid-ub25-integer-length: Internal types
Type, uuid-ub32: Internal types
Type, uuid-ub33-integer-length: Internal types
Type, uuid-ub48: Internal types
Type, uuid-ub49-integer-length: Internal types
Type, uuid-ub64: Internal types
Type, uuid-ub64-integer-length: Internal types
Type, uuid-ub8: Internal types
Type, uuid-ub9-integer-length: Internal types
Type, uuid-unsigned-byte-integer-length: Internal types
Type, uuid-unsigned-byte-size: Internal types
Type, uuid-v3-4-or-5-int: Internal types
Type, uuid-v3-or-5-int: Internal types
Type, uuid-version-int: Internal types

U
unicly: The unicly system
unicly: The unicly package
unicly-asd: The unicly-asd package
unique-universal-identifier: Exported classes
unique-universal-identifier-null: Internal classes
uuid-bit-48-error: Internal conditions
uuid-bit-vector: Internal types
uuid-bit-vector-128: Internal types
uuid-bit-vector-128-length: Internal types
uuid-bit-vector-16: Internal types
uuid-bit-vector-16-length: Internal types
uuid-bit-vector-32: Internal types
uuid-bit-vector-32-length: Internal types
uuid-bit-vector-48: Internal types
uuid-bit-vector-48-length: Internal types
uuid-bit-vector-8: Internal types
uuid-bit-vector-8-length: Internal types
uuid-bit-vector-index: Internal types
uuid-bit-vector-length: Internal types
uuid-bit-vector-null: Internal types
uuid-bit-vector-valid-bit-offset: Internal types
uuid-bit-vector-valid-bit-width: Internal types
uuid-bit-vector-valid-length: Internal types
uuid-byte-array: Internal types
uuid-byte-array-16: Internal types
uuid-byte-array-20: Internal types
uuid-byte-array-null: Internal types
uuid-byte-string: Internal types
uuid-error: Internal conditions
uuid-hex-string-12: Internal types
uuid-hex-string-2: Internal types
uuid-hex-string-32: Internal types
uuid-hex-string-36: Internal types
uuid-hex-string-4: Internal types
uuid-hex-string-8: Internal types
uuid-hex-string-length: Internal types
uuid-simple-error: Internal conditions
uuid-simple-string-vector-5: Internal types
uuid-simple-type-error: Internal conditions
uuid-simple-vector-5: Internal types
uuid-slot-type-error: Internal conditions
uuid-slot-unbound-error: Internal conditions
uuid-string-32: Internal types
uuid-string-36: Internal types
uuid-ub128: Internal types
uuid-ub128-integer-length: Internal types
uuid-ub16: Internal types
uuid-ub24: Internal types
uuid-ub25-integer-length: Internal types
uuid-ub32: Internal types
uuid-ub33-integer-length: Internal types
uuid-ub48: Internal types
uuid-ub49-integer-length: Internal types
uuid-ub64: Internal types
uuid-ub64-integer-length: Internal types
uuid-ub8: Internal types
uuid-ub9-integer-length: Internal types
uuid-unsigned-byte-integer-length: Internal types
uuid-unsigned-byte-size: Internal types
uuid-v3-4-or-5-int: Internal types
uuid-v3-or-5-int: Internal types
uuid-version-int: Internal types

Jump to:   C   H   N   P   S   T   U