Common Lisp Package: X.FDATATYPES

README:

FUNCTION

Public

Undocumented

FSET (&REST INITIAL-CONTENTS)

FSET-EX (&KEY (KEY-TEST #'EQUAL) (HASH-FUN #'SXHASH))

FTAB (&REST INITIAL-CONTENTS)

FTAB-EX (&KEY (KEY-TEST #'EQUAL) (VAL-TEST #'EQ) (HASH-FUN #'SXHASH))

FVEC (&REST INITIAL-CONTENTS)

Private

BITMAP-INDEXED-NODE-BITMAP (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BITMAP-INDEXED-NODE-HASH (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BITMAP-INDEXED-NODE-NODES (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BITMAP-INDEXED-NODE-SHIFT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CHUNK-BUFFER-ARRAY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CHUNK-BUFFER-INDEX (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

EMPTY-NODE-HASH (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FSET-TAB-CTX (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FTAB-TAB-CTX (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FULL-NODE-HASH (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FULL-NODE-NODES (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FULL-NODE-SHIFT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FVEC-VEC-CTX (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

HASH-COLLISION-NODE-HASH (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

HASH-COLLISION-NODE-LEAVES (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

INODE-HASH (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

LEAF-NODE-HASH (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

LEAF-NODE-KEY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

LEAF-NODE-VAL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TAB-CTX-COUNT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TAB-CTX-HASH-FUN (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TAB-CTX-ITERATOR-CURSOR (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TAB-CTX-KEY-TEST (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TAB-CTX-ROOT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TAB-CTX-VAL-TEST (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VEC-CTX-COUNT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VEC-CTX-ITERATOR-INDEX (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VEC-CTX-ITERATOR-ROOT-PATH (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VEC-CTX-ITERATOR-TAIL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VEC-CTX-ROOT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VEC-CTX-SHIFT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

VEC-CTX-TAIL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

Undocumented

%MAKE-BITMAP-INDEXED-NODE (&KEY ((HASH DUM927) 0) ((BITMAP DUM928) (ERROR no bitmap)) ((NODES DUM929) (ERROR no nodes)) ((SHIFT DUM930) (ERROR no shift)))

%MAKE-FSET (&KEY ((TAB-CTX DUM130) (ERROR no context)))

%MAKE-FTAB (&KEY ((TAB-CTX DUM151) (ERROR no context)))

%MAKE-FULL-NODE (&KEY ((HASH DUM491) 0) ((NODES DUM492) (ERROR no nodes)) ((SHIFT DUM493) (ERROR no shift)))

%MAKE-FVEC (&KEY ((VEC-CTX DUM38) (ERROR no context)))

%MAKE-TAB-CTX-ITERATOR (&KEY ((CURSOR DUM200) NIL))

%MAKE-VEC-CTX-ITERATOR (&KEY ((ROOT-PATH DUM54) NIL) ((TAIL DUM55) NIL) ((INDEX DUM56) NIL))

%REEVALUATE-CONSTANT (NAME VALUE TEST)

BAD-VALUE-FOR-KEY (KEY CONTAINER DATUM)

BIT-POSITION (HASH SHIFT)

SETFBITMAP-INDEXED-NODE-BITMAP (NEW-VALUE INSTANCE)

SETFBITMAP-INDEXED-NODE-HASH (NEW-VALUE INSTANCE)

SETFBITMAP-INDEXED-NODE-NODES (NEW-VALUE INSTANCE)

BITMAP-INDEXED-NODE-P (OBJECT)

SETFBITMAP-INDEXED-NODE-SHIFT (NEW-VALUE INSTANCE)

BUILD-TREES-FROM-CONTENT (CONTENT CONTENT-LENGTH LEVEL CHUNK-LENGTH)

BUILD-VEC-CTX (CONTENT CONTENT-LENGTH BEFORE-LAST WORK-ARRAY WORK-INDEX)

SETFCHUNK-BUFFER-ARRAY (NEW-VALUE INSTANCE)

SETFCHUNK-BUFFER-INDEX (NEW-VALUE INSTANCE)

CHUNK-BUFFER-P (OBJECT)

CHUNK-INDEXES (CHUNK-ID INDEXES)

COPY-BITMAP-INDEXED-NODE (INSTANCE)

COPY-CHUNK-BUFFER (BUF COLLECT-FN CHUNK START END)

COPY-EMPTY-NODE (INSTANCE)

COPY-FSET (INSTANCE)

COPY-FTAB (INSTANCE)

COPY-FULL-NODE (INSTANCE)

COPY-FVEC (INSTANCE)

COPY-HASH-COLLISION-NODE (INSTANCE)

COPY-INODE (INSTANCE)

COPY-LEAF-NODE (INSTANCE)

COPY-TAB-CTX (INSTANCE)

COPY-TAB-CTX-ITERATOR (INSTANCE)

COPY-VEC-CTX (INSTANCE)

COPY-VEC-CTX-ITERATOR (INSTANCE)

CREATE-NODE (BITMAP NODES SHIFT)

CREATE-NODE-WITH-LEAF (TAB-CTX SHIFT BRANCH HASH KEY VAL)

SETFEMPTY-NODE-HASH (NEW-VALUE INSTANCE)

EMPTY-NODE-P (OBJECT)

ENSURE-CHUNK-BUFFER (BUF)

EXPAND-CLONE-SIMPLE-VECTOR (ORIG INDEX VALUE)

FIND-INDEX (TAB-CTX NODE HASH KEY)

FSET-P (OBJECT)

SETFFSET-TAB-CTX (NEW-VALUE INSTANCE)

FTAB-P (OBJECT)

SETFFTAB-TAB-CTX (NEW-VALUE INSTANCE)

SETFFULL-NODE-HASH (NEW-VALUE INSTANCE)

SETFFULL-NODE-NODES (NEW-VALUE INSTANCE)

FULL-NODE-P (OBJECT)

SETFFULL-NODE-SHIFT (NEW-VALUE INSTANCE)

FUNCTION-NAME (FUNCTION)

FVEC-P (OBJECT)

SETFFVEC-VEC-CTX (NEW-VALUE INSTANCE)

SETFHASH-COLLISION-NODE-HASH (NEW-VALUE INSTANCE)

SETFHASH-COLLISION-NODE-LEAVES (NEW-VALUE INSTANCE)

HASH-COLLISION-NODE-P (OBJECT)

INDEX (NODE BIT)

SETFINODE-HASH (NEW-VALUE INSTANCE)

INODE-P (OBJECT)

SETFLEAF-NODE-HASH (NEW-VALUE INSTANCE)

SETFLEAF-NODE-KEY (NEW-VALUE INSTANCE)

LEAF-NODE-P (OBJECT)

SETFLEAF-NODE-VAL (NEW-VALUE INSTANCE)

MAKE-BITMAP-INDEXED-NODE (&KEY BITMAP NODES SHIFT)

MAKE-CHUNK-BUFFER (&KEY ((ARRAY DUM1374) NIL) ((INDEX DUM1375) 0))

MAKE-EMPTY-NODE (&KEY ((HASH DUM284) 0))

MAKE-FULL-NODE (&KEY NODES SHIFT)

MAKE-HASH-COLLISION-NODE (&KEY ((HASH DUM1935) 0) ((LEAVES DUM1936) (ERROR no leaves)))

MAKE-INODE (&KEY ((HASH DUM0) 0))

MAKE-LEAF-NODE (&KEY ((HASH DUM361) 0) ((KEY DUM362) (ERROR no key)) ((VAL DUM363) (ERROR no val)))

MAKE-TAB-CTX (&KEY ((COUNT DUM36) 0) ((ROOT DUM37) (ERROR no root)) ((HASH-FUN DUM38) (ERROR no hash-fun)) ((KEY-TEST DUM39) (ERROR no key-test)) ((VAL-TEST DUM40) (ERROR no val-test)))

MAKE-VEC-CTX (&KEY ((COUNT DUM0) 0) ((SHIFT DUM1) (ERROR no shift)) ((ROOT DUM2) (ERROR no root)) ((TAIL DUM3) (ERROR no tail)))

MAP-ASSOCIATIONS (FN SEQUENCE CONTAINER)

MAP-ASSOCIATIONS-1 (FN SEQUENCE CONTAINER &KEY BAD-VALUE-FN BAD-VALUE-DATUM)

MAP-SIMPLE-VECTOR-FROM-END (FUNCTION VECTOR)

MASK (HASH SHIFT)

MAYBE-NTH-SPLIT (LIST N)

NTH-SPLIT (LIST N)

SHRINK-CLONE-SIMPLE-VECTOR (ORIG INDEX)

TAB-CTX-ADD (TAB-CTX KEY VAL)

SETFTAB-CTX-COUNT (NEW-VALUE INSTANCE)

TAB-CTX-DEL (TAB-CTX KEY)

SETFTAB-CTX-HASH-FUN (NEW-VALUE INSTANCE)

TAB-CTX-ITERATOR (TAB-CTX)

SETFTAB-CTX-ITERATOR-CURSOR (NEW-VALUE INSTANCE)

TAB-CTX-ITERATOR-NEXT (TAB-CTX-ITERATOR)

TAB-CTX-ITERATOR-P (OBJECT)

SETFTAB-CTX-KEY-TEST (NEW-VALUE INSTANCE)

TAB-CTX-MAP (TAB-CTX LEAF-NODE-FN &OPTIONAL FROM-END)

TAB-CTX-P (OBJECT)

TAB-CTX-REF (TAB-CTX KEY)

SETFTAB-CTX-ROOT (NEW-VALUE INSTANCE)

SETFTAB-CTX-VAL-TEST (NEW-VALUE INSTANCE)

TAIL-OFF (VEC-CTX)

TEST-FTAB-ADD (N &KEY RESULT)

TEST-FTAB-DEL (TAB N)

TEST-FTAB-REF (TAB N)

TEST-FVEC-ADD-TAIL (N &KEY RESULT)

TEST-FVEC-DEL-TAIL (VEC N)

TEST-FVEC-REF (VEC N)

TEST-HASHTABLE-ADD (N &KEY RESULT)

TEST-HASHTABLE-DEL (H N)

TEST-HASHTABLE-REF (H N)

UNZIP-ALIST (ALIST)

VEC-CTX-ADD (VEC-CTX INDEX VAL)

VEC-CTX-ADD* (VEC-CTX CONTENTS)

VEC-CTX-ADD*-BUILD-CONTENT (VEC-CTX IDXS VALS)

VEC-CTX-ADD*-HELPER (VEC-CTX IDXS VALS)

VEC-CTX-ADD-TAIL (VEC-CTX VAL)

VEC-CTX-ADD-TAIL* (VEC-CTX CONTENTS)

SETFVEC-CTX-COUNT (NEW-VALUE INSTANCE)

VEC-CTX-DEL (VEC-CTX INDEX)

VEC-CTX-DEL* (VEC-CTX INDEXES)

VEC-CTX-DEL*-BUILD-CONTENT (VEC-CTX INDEXES)

VEC-CTX-DEL*-HELPER (VEC-CTX INDEXES)

VEC-CTX-DEL-TAIL (VEC-CTX)

VEC-CTX-IOTA (N &OPTIONAL (START 0) (STEP 1))

VEC-CTX-ITERATOR (VEC-CTX)

SETFVEC-CTX-ITERATOR-INDEX (NEW-VALUE INSTANCE)

VEC-CTX-ITERATOR-NEXT (VEC-CTX-ITERATOR)

VEC-CTX-ITERATOR-P (OBJECT)

SETFVEC-CTX-ITERATOR-ROOT-PATH (NEW-VALUE INSTANCE)

SETFVEC-CTX-ITERATOR-TAIL (NEW-VALUE INSTANCE)

VEC-CTX-MAP (VEC-CTX FUNCTION &OPTIONAL FROM-END)

VEC-CTX-MAP-CHUNKS (VEC-CTX FUNCTION)

VEC-CTX-P (OBJECT)

VEC-CTX-PROCESS-CONTENTS (VEC-CTX ONE-ELEM-FN MANY-ELEMS-FN CONTENTS)

VEC-CTX-REF (VEC-CTX KEY)

SETFVEC-CTX-ROOT (NEW-VALUE INSTANCE)

SETFVEC-CTX-SHIFT (NEW-VALUE INSTANCE)

SETFVEC-CTX-TAIL (NEW-VALUE INSTANCE)

VEC-CTX-UPDATE (VEC-CTX INDEX VAL)

VEC-CTX-UPDATE* (VEC-CTX CONTENTS)

VEC-CTX-UPDATE*-HELPER (VEC-CTX IDXS VALS)

MACRO

Private

Undocumented

DEFINE-CONSTANT (NAME INITIAL-VALUE &KEY (TEST ''EQL) DOCUMENTATION)

NCONCING ((&KEY (INIT NIL) (INTO 'NCONC-RESULT) (CALL 'NCONC-IT) (COUNT NIL) (LAST NIL) (BEFORE-LAST NIL)) &BODY BODY)

GENERIC-FUNCTION

Public

Undocumented

ADD (CONTAINER KEY VAL)

ADD* (CONTAINER &REST CONTENTS)

ADD-KEY (CONTAINER KEY)

ADD-KEY* (CONTAINER &REST KEYS)

ADD-TAIL (CONTAINER VAL)

ADD-TAIL* (CONTAINER &REST VALS)

COERCE-FSET (X &KEY (HASH-FUN #'SXHASH) (KEY-TEST #'EQUAL))

COERCE-FTAB (X &KEY (KEY-TEST #'EQUAL) (VAL-TEST #'EQ) (HASH-FUN #'SXHASH))

COERCE-FVEC (X)

DEL (CONTAINER KEY)

DEL* (CONTAINER &REST KEYS)

DEL-TAIL (CONTAINER)

DEL-TAIL* (CONTAINER COUNT)

EMPTY (CONTAINER)

FILTER (CONTAINER PREDICATE &KEY FROM-END)

FMAP (CONTAINER FUNCTION &KEY FROM-END)

FMAP-TO (RESULT-TYPE CONTAINER FUNCTION &KEY FROM-END)

FOLD (CONTAINER FUNCTION &KEY INIT FROM-END (INIT 0))

FSET-DIFFERENCE (X &REST FSETS)

FSET-EXCLUSIVE-OR (X Y)

FSET-LIST (X)

FSET-UNION (CONTAINER &REST CONTAINERS)

FSET-VECTOR (X)

FTAB-ALIST (X)

FVEC-IOTA (N &KEY (START 0) (STEP 1))

FVEC-LIST (X)

FVEC-VECTOR (X)

HAS-KEY (CONTAINER KEY)

HAS-KEY* (CONTAINER &REST KEYS)

ITERATOR (CONTAINER)

ITERATOR-NEXT (ITERATOR)

KEYS (CONTAINER)

REF (CONTAINER KEY)

REF* (CONTAINER &REST KEYS)

REF-OPT (CONTAINER OPTIONAL KEY)

REF-OPT* (CONTAINER OPTIONAL &REST KEYS)

REF-OPT-FN* (CONTAINER OPTIONAL-FN &REST KEYS)

SEQUENCE-FSET (XS &KEY (KEY-TEST #'EQUAL) (HASH-FUN #'SXHASH))

SIZE (CONTAINER)

UPDATE (CONTAINER INDEX VAL)

UPDATE* (CONTAINER &REST CONTENTS)

VALS (CONTAINER)

Private

Undocumented

BAD-INDEX (CONDITION)

INODE-ADD (TAB-CTX NODE SHIFT HASH KEY VAL)

INODE-DEL (TAB-CTX NODE HASH KEY)

INODE-MAP (NODE LEAF-NODE-FN FROM-END)

INODE-REF (TAB-CTX NODE HASH KEY)

KEY (CONDITION)

LIMIT (CONDITION)

CLASS

Public

Undocumented

FSET (&REST INITIAL-CONTENTS)

FTAB (&REST INITIAL-CONTENTS)

FVEC (&REST INITIAL-CONTENTS)

Private

Undocumented

BITMAP-INDEXED-NODE

CHUNK-BUFFER

EMPTY-NODE

FULL-NODE

HASH-COLLISION-NODE

INODE

LEAF-NODE

TAB-CTX

TAB-CTX-ITERATOR (TAB-CTX)

VEC-CTX

VEC-CTX-ITERATOR (VEC-CTX)

CONDITION

Private

Undocumented

CONTAINER-EMPTY

INVALID-ARGUMENTS

NOT-FOUND

OUT-OF-BOUNDS

RETURN-CONTAINER-AS-IS

CONSTANT

Private

Undocumented

+EMPTY-VEC+

+EMPTY-VEC-CTX+

+VEC-CTX-BLOCK-SIZE+

+VEC-CTX-SHIFT+