Current File : //proc/self/root/kunden/usr/share/emacs/27.2/lisp/emacs-lisp/radix-tree.elc

;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


#@23 

(fn TREE KEY VAL I)
(defalias 'radix-tree--insert #[1028 "\300:\203\300@\211:\203\244\211@
AA\211
G\\\301\302\211&\211\303=\203A\304$
BB\262
\202\233\211\305W\203M\306
Z\202O\211S\211\305U\203j\304$B
B\262
\202\231\307\305#\307\\\"\307\"
\310\232\203\207\202\214
BC\nBBB\nB\266\204\262
\266\202\266\203\266\203\202\273GU\203\257\202\273\307\"\211BB\262
\262
\202\306\211$\207" [#[1028 "G
U\203	
\207\300\"\211BB\207" [substring] 7 "\n\n(fn TREE KEY VAL I)"] compare-strings nil t radix-tree--insert 0 -1 substring ""] 22 (#$ . 408)])
#@19 

(fn TREE KEY I)
(defalias 'radix-tree--remove #[771 "\300:\203\313@\211:\203\275\211@
AA\211
G\\\301\302\211&\211\303=\203\211\304
#\305
\204>\202\204
:\203}
@\211:\203q\211@
AA\211\204d
\n
PB
B\266\202\202l\n#\266\203\202x
#\262
\202\204\211#\266\202\202\264\211\306W\203\225\307
Z\202\227\211S\211\306U\203\260\304#B
B\262
\202\262
\262
\266\202\266\203\266\203\202\306GU?\205\306\262
\202\320\211#\207" [#[771 "
G
U?\205	\207" #1=[] 5 "\n\n(fn TREE KEY I)"] compare-strings nil t radix-tree--remove #[771 "

BB\207" #1# 5 "\n\n(fn RTREE PREFIX NPTREE)"] 0 -1] 23 (#$ . 1037)])
#@22 

(fn TREE STRING I)
(defalias 'radix-tree--lookup #[771 "\300:\203p@\211:\203e\211@
AA\211
G\\\301\302\211&\211\303=\2037\304
#\202\\\211\305W\203C\306
Z\202E\211S\211\305U\203V\304#\202Z
\\\262
\266\202\266\203\266\203\202k
#\262
\202v\211#\207" [#[771 "\211\203G\232\203\211\250\203\300
B\207\207
\207" [t] 5 "\n\n(fn STRING I VAL)"] compare-strings nil t radix-tree--lookup 0 -1] 19 (#$ . 1705)])
#@31 

(fn TREE STRING I PREFIXES)
(defalias 'radix-tree--prefixes #[1028 "\300:\203\\@\211:\203P\211@
AA\211	
G\\\301\302\211&\n\303$\304=\203F\303$\202G\211\266\204\266\203\266\203\202W
	$\262
\202c\211$\207" [#[1028 "\211\204
\207\300\301#
\242\302=\203
A\202
BB\207" [substring 0 t] 8 "\n\n(fn STRING I PREFIXES VAL)"] compare-strings nil radix-tree--prefixes t] 21 (#$ . 2165)])
#@22 

(fn TREE STRING I)
(defalias 'radix-tree--subtree #[771 "
G
\232\203	\207:\205\201@\211:\205\211@
AA\211
G\\\300\301\211

&\211\302=\203>\303\f#\202y\211\304W\203J\305
Z\202L\211S\211\304U\203]\303

#\202w\211\\\fG\232\203v\306\"\211BC\262
\202w\301\262
\266\202\266\203\266\203\262
\207" [compare-strings nil t radix-tree--subtree 0 -1 substring] 18 (#$ . 2606)])
#@23 The empty radix-tree.
(defconst radix-tree-empty nil (#$ . 3019))
#@68 Insert a mapping from KEY to VAL in radix TREE.

(fn TREE KEY VAL)
(defalias 'radix-tree-insert #[771 "\211:\203\n\300
B\262
\211\203\301\302$\207\303\302#\207" [t radix-tree--insert 0 radix-tree--remove] 8 (#$ . 3091)])
#@92 Return the value associated to KEY in radix TREE.
If not found, return nil.

(fn TREE KEY)
(defalias 'radix-tree-lookup #[514 "\300\301#\211:\203&\211@\211\302=\203
A\211\211\262
\262
\202!
\211\262
\262
\2023\211\247\203/\303\2023\211\211\262
\207" [radix-tree--lookup 0 t nil] 7 (#$ . 3326)])
#@75 Return the subtree of TREE rooted at the prefix STRING.

(fn TREE STRING)
(defalias 'radix-tree-subtree #[514 "\300\301#\207" [radix-tree--subtree 0] 6 (#$ . 3636)])
#@83 Return an alist of all bindings in TREE for prefixes of STRING.

(fn TREE STRING)
(defalias 'radix-tree-prefixes #[514 "\300\301\302$\207" [radix-tree--prefixes 0 nil] 7 (#$ . 3810)])
#@115 Pattern which matches a radix-tree leaf.
The pattern VPAT is matched against the leaf's carried value.

(fn VPAT)
(defalias 'radix-tree-leaf--pcase-macroexpander #[257 "\300\301\302\303CBBCB\304\305EE\207" [or \` t \, and (pred atom)] 6 (#$ . 4003)])
(byte-code "\300\301\302\303#\300\304\305\301#\303\207" [define-symbol-prop radix-tree-leaf--pcase-macroexpander edebug-form-spec nil radix-tree-leaf pcase-macroexpander] 5)
#@226 Apply FUN to every immediate subtree of radix TREE.
FUN is called with two arguments: PREFIX and SUBTREE.
You can test if SUBTREE is a leaf (and extract its value) with the
pcase pattern (radix-tree-leaf PAT).

(fn TREE FUN)
(defalias 'radix-tree-iter-subtrees #[514 "
C\211\242\205F\300
\242:\203=
\242@\211:\203/\211@
A\242A\211	
\"\210\240\266\2029\301\242\"\210\302\240\210\210\202B\211\"\210\210\202\207" [#[514 "\211\300\242\"\210
\301\240\207" [#1="" nil] 5 "\n\n(fn TREE FUN)"] #1# nil] 14 (#$ . 4437)])
#@148 Apply FUN to every mapping in TREE.
FUN is called with two arguments: KEY and VAL.
PREFIX is only used internally.

(fn TREE FUN &optional PREFIX)
(defalias 'radix-tree-iter-mappings #[770 "\300\301\302\303\304\305\"\306\"\307\310%\"\207" [radix-tree-iter-subtrees make-byte-code 514 "\301P
:\203(
@\211\302=\203A\211\300\"\262
\262
\202#\303\300#\262
\202<
:\2047
\300\"\262
\202<\303\300#\207" vconcat vector [t radix-tree-iter-mappings] 9 "\n\n(fn P S)"] 12 (#$ . 4978)])
#@13 

(fn TREE)
(defalias 'radix-tree-count #[257 "\300C\301\302\303\304\305\306!\307\"\310\311%\"\210\211\242\207" [0 radix-tree-iter-mappings make-byte-code 514 "\300\211\242T\240\207" vconcat vector [] 4 "\n\n(fn K V)"] 10 (#$ . 5481)])
#@12 

(fn MAP)
(defalias 'radix-tree-from-map #[257 "\300\301!\210\302C\303\304\305\306\307\310!\311\"\312\313%\"\210\211\242\207" [require map nil map-apply make-byte-code 514 "\300\301\300\242#\240\207" vconcat vector [radix-tree-insert] 7 "\n\n(fn K V)"] 9 (#$ . 5726)])
(provide 'radix-tree)