hitchhiker.tree.core — io.replikativ/hitchhiker-tree 0.1.2-SNAPSHOT

<? clj/s macro

(<? ch)

Same as core.async <! but throws an exception if the channel returns a throwable error.

<?? clj

(<?? ch)

Same as core.async <!! but throws an exception if the channel returns a throwable error.

<?resolve clj/s macro

(<?resolve e)

HACK Attempt faster inlined resolve to avoid unnecessary channel ops.

b-tree clj/s

(b-tree cfg & kvs)

backtrack-up-path-until clj/s

(backtrack-up-path-until path pred)

Given a path (starting with root and ending with an index), searches backwards, passing each pair of parent & index we just came from to the predicate function. When that function returns true, we return the path ending in the index for which it was true, or else we return the empty path

chan-seq clj

(chan-seq ch)

Config cljs

data-node clj/s

(data-node cfg children)

Creates a new data node

data-node? clj/s

(data-node? node)

DataNode cljs

delete clj/s

(delete {:keys [cfg] :as tree} key)

dirty! clj/s

(dirty! node)

Marks a node as being dirty if it was clean

flush-children clj/s

(flush-children children backend session)

flush-children-without-root clj/s

(flush-children-without-root children backend session)

flush-tree clj/s

(flush-tree tree backend)

(flush-tree tree backend stats)

Given the tree, finds all dirty nodes, delivering addrs into them. Every dirty node also gets replaced with its TestingAddr. These form a GC cycle, have fun with the unmanaged memory port :)

flush-tree-without-root clj/s

(flush-tree-without-root tree backend)

(flush-tree-without-root tree backend stats root-node?)

Given the tree, finds all dirty nodes, delivering addrs into them.

Does not flush root node, but returns it.

forward-iterator clj/s≠

clj

(forward-iterator path start-key)

Takes the result of a search and returns an iterator going forward over the tree. Does lg(n) backtracking sometimes.

cljs

(forward-iterator iter-ch path start-key)

Takes the result of a search and puts the iterated elements onto iter-ch going forward over the tree as needed. Does lg(n) backtracking sometimes.

go-try clj/s macro

(go-try & body)

Asynchronously executes the body in a go block. Returns a channel which will receive the result of the body when completed or the exception if an exception is thrown. You are responsible to take this exception and deal with it! This means you need to take the result from the channel at some point.

IBackend clj/s≠ protocol

anchor-root clj/s

(anchor-root backend node)

Tells the backend this is a temporary root

delete-addr clj/s

(delete-addr backend addr session)

Deletes the given addr from storage

new-session clj/s

(new-session backend)

Returns a session object that will collect stats

write-node clj/s

(write-node backend node session)

Writes the given node to storage, returning a go-block with its assigned address

if-cljs clj/s macro

(if-cljs then else)

Return then if we are generating cljs code and else for Clojure code. https://groups.google.com/d/msg/clojurescript/iBY5HaQda4A/w1lAQi9_AwsJ

IKeyCompare clj/s≠ protocol

compare clj/s

(compare key1 key2)

index-node-keys clj/s

(index-node-keys children)

Calculates the separating keys given the children of an index node

index-node? clj/s

(index-node? node)

IndexNode cljs

INode clj/s≠ protocol

lookup clj/s

(lookup node key)

Returns the child node which contains the given key

merge-node clj/s

(merge-node node other)

Combines this node with the other to form a bigger node. We assume they're siblings

overflow? clj/s

(overflow? node)

Returns true if this node has too many elements

split-node clj/s

(split-node node)

Returns a Split object with the 2 nodes that we turned this into

underflow? clj/s

(underflow? node)

Returns true if this node has too few elements

insert clj/s

(insert {:keys [cfg] :as tree} key value)

IResolve clj/s≠ protocol

All nodes must implement this protocol. It's includes the minimal functionality necessary to avoid resolving nodes unless strictly necessary.

dirty? clj/s

(dirty? _)

Returns true if this should be flushed

index? clj/s

(index? _)

Returns true if this is an index node

last-key clj/s

(last-key _)

Returns the rightmost key of the node

resolve clj/s

(resolve _)

Returns the INode version of this node in a go-block; could trigger IO

lookup-fwd-iter clj/s

(lookup-fwd-iter tree key)

lookup-key clj/s

(lookup-key tree key)

(lookup-key tree key not-found)

Given a B-tree and a key, gets an iterator into the tree

lookup-path clj/s

(lookup-path tree key)

Given a B-tree and a key, gets a path into the tree

node-status-bits clj

(node-status-bits node)

nth-of-set clj/s

(nth-of-set set index)

Like nth, but for sorted sets. O(n)

order-on-edn-types clj/s

(order-on-edn-types t)

print-data-node clj

(print-data-node node writer fully-qualified?)

print-index-node clj

(print-index-node node writer fully-qualified?)

Optionally include

print-testing-addr clj

(print-testing-addr node writer fully-qualified?)

reduce< clj/s

(reduce< go-f init s)

Reduces over a sequence s with a go function go-f given the initial value init.

right-successor clj/s

(right-successor path)

Given a node on a path, find's that node's right successor node

Split cljs

TestingAddr cljs

TestingBackend cljs

throw-if-exception clj/s

(throw-if-exception x)

Helper method that checks if x is Exception and if yes, wraps it in a new exception, passing though ex-data if any, and throws it. The wrapping is done to maintain a full stack trace when jumping between multiple contexts.

tree-node? clj/s

(tree-node? node)