reitit.trie — metosin/reitit 0.5.1

catch-all? clj/s

(catch-all? x)

CatchAll clj/s

clojure-trie-compiler clj/s

(clojure-trie-compiler)

compile clj/s

(compile options)

(compile options compiler)

(compile {:keys [data params children wilds catch-all] :or {params {}}}
         compiler
         cp)

Returns a compiled trie, to be used with pretty or path-matcher.

compiler clj/s

(compiler)

Returns a default TrieCompiler.

conflicting-parts? clj/s

(conflicting-parts? parts1 parts2)

conflicting-paths? clj/s

(conflicting-paths? path1 path2 opts)

insert clj/s

(insert routes)

(insert node routes)

(insert node path data)

(insert
  node
  path
  data
  {:reitit.trie/keys [parameters] :or {parameters map-parameters} :as opts})

Returns a trie with routes added to it.

java-trie-compiler clj

(java-trie-compiler)

join-path clj/s

(join-path xs)

Match clj/s

Matcher clj/s protocol

depth clj/s

(depth this)

length clj/s

(length this)

match clj/s

(match this i max path)

view clj/s

(view this)

Node clj/s

normalize clj/s

(normalize s opts)

path-matcher clj/s

(path-matcher compiled-trie)

(path-matcher compiled-trie compiler)

Returns a function of path -> Match from a compiled trie.

pretty clj/s

(pretty compiled-trie)

(pretty compiled-trie compiler)

Returns a simplified EDN structure of a compiled trie for printing purposes.

record-parameters clj

Memoized function to transform parameters into runtime generated Record.

split-path clj/s

(split-path s {:keys [syntax] :or {syntax #{:colon :bracket}}})

TrieCompiler clj/s protocol

-path-matcher clj/s

(-path-matcher this matcher)

-pretty clj/s

(-pretty this matcher)

catch-all-matcher clj/s

(catch-all-matcher this key params data)

data-matcher clj/s

(data-matcher this params data)

linear-matcher clj/s

(linear-matcher this matchers ordered?)

static-matcher clj/s

(static-matcher this path matcher)

wild-matcher clj/s

(wild-matcher this key end matcher)

Wild clj/s

wild? clj/s

(wild? x)