com.manigfeald.dset — com.manigfeald/dset 2.0.0

apply-delta clj

(apply-delta a [delta-triples delta-cc :as delta])

Given a dset and a delta, apply the delta to the dset

assert-triple clj

(assert-triple {:keys [eav aev ave ds casual-context delta] :as base}
               replica-id
               triple)

Add a triple to the dset at the replica-id

cmp clj

(cmp a b)

cmp-aev clj

(cmp-aev a b)

cmp-ave clj

(cmp-ave a b)

cmp-eav clj

(cmp-eav a b)

delta clj

dot-compact clj

(dot-compact context)

dot-context clj

(dot-context)

(dot-context cc)

(dot-context cc dc)

A dot context is essentially a special purpose set. All the values in the set are tuples of the form [node-id event-clock], and with one exception we know that if [X N+1] is in the dot context, then [X N] is also in the context, which allows the set to be represented as a map of {node-id event-clock}. The dot context can also contain, for a given node-id, a single [node-id event-clock], where N+1 doesn't imply N. For that case we still need a set. So a dot context is a set represented as a map and a set.

dot-dom? clj

(dot-dom? sup sub)

Is sup a superset of sub?

dot-empty? clj

(dot-empty? c)

dot-in? clj

(dot-in? context [key value :as dot])

dot-insert clj

(dot-insert context [k value])

(dot-insert context k value compact?)

dot-join clj

(dot-join c1 c2)

dot-make clj

(dot-make {:as context :keys [cc dc]} id kont)

empty-dot-context clj

join clj

(join a b)

Given two dsets, return a new dset which is a merge of the casual history of the two

join-deltas clj

(join-deltas [a1 a2 :as a] [b1 b2 :as b])

make clj

(make)

Return an empty dset.

this triple store is more or less a large set of triples, it happens to also store some indices that make certain operations on the set more efficient. But the supported operations and the mechanics of the crdt remain that of a aworset.

query clj

(query {:keys [eav aev ave]} [a b c :as question])

Given a dset, return a seq of tuples that match the tuple pattern given. Patterns a tuples with nils for blanks.

retract-triple clj

(retract-triple {:keys [eav aev ave ds casual-context delta] :as base}
                replica-id
                triple)

Remove a triple from the dset at the replica-id

values clj

(values {:keys [eav]})

Get the set in the dset, don't use this

without-delta clj

(without-delta base)