clara.rules.engine — com.cerner/clara-rules 0.20.0

This namespace is for internal use and may move in the future. Most users should use only the clara.rules namespace.

*current-session* clj/s

*pending-external-retractions* clj/s

*rule-context* clj/s

AccumulateNode cljs

AccumulateWithJoinFilterNode cljs

Accumulator cljs

Activation cljs

AlphaNode cljs

assemble clj/s

(assemble {:keys [rulebase memory transport listeners get-alphas-fn]})

Assembles a session from the given components, which must be a map containing the following:

:rulebase A recorec matching the clara.rules.compiler/Rulebase structure. :memory An implementation of the clara.rules.memory/IMemoryReader protocol :transport An implementation of the clara.rules.engine/ITransport protocol :listeners A vector of listeners implementing the clara.rules.listener/IPersistentListener protocol :get-alphas-fn The function used to return the alpha nodes for a fact of the given type.

conj-rulebases clj/s

(conj-rulebases base1 base2)

DEPRECATED. Simply concat sequences of rules and queries.

Conjoin two rulebases, returning a new one with the same rules.

Element cljs

empty-token clj/s

ExpressionJoinNode cljs

find-listeners clj/s

(find-listeners session pred)

Return all listeners on the session matching the predicate.

fire-rules* clj/s

(fire-rules* rulebase
             nodes
             transient-memory
             transport
             listener
             get-alphas-fn
             update-cache)

Fire rules for the given nodes.

get-conditions-and-rule-names clj/s

(get-conditions-and-rule-names node)

Returns a map from conditions to sets of rules.

get-terminal-node-types clj/s

(get-terminal-node-types node)

HashJoinNode cljs

IAccumInspect clj/s≠ protocol

This protocol is expected to be implemented on accumulator nodes in the rules network. It is not expected that users will implement this protocol, and most likely will not call the protocol function directly.

token->matching-elements clj/s

(token->matching-elements node memory token)

Takes a token that was previously propagated from the node, or a token that is a descendant of such a token, and returns the facts in elements matching the token propagated from the node. During rules firing accumulators only propagate bindings created and the result binding downstream rather than all facts that were accumulated over, but there are use-cases in session inspection where we want to retrieve the individual facts.

Example: [?min-temp <- (acc/min :temperature) :from [Temperature (= temperature ?loc)]] [?windspeed <- [WindSpeed (= location ?loc)]]

Given a token propagated from the node for the WindSpeed condition we could retrieve the Temperature facts from the matching location.

IAccumRightActivate clj/s≠ protocol

pre-reduce clj/s

(pre-reduce node elements)

right-activate-reduced clj/s

(right-activate-reduced node join-bindings reduced memory transport listener)

IAlphaActivate clj/s≠ protocol

alpha-retract clj/s

(alpha-retract node facts memory transport listener)

alpha-activate clj/s

(alpha-activate node facts memory transport listener)

IConditionNode clj/s≠ protocol

get-condition-description clj/s

(get-condition-description this)

ILeftActivate clj/s≠ protocol

description clj/s

(description node)

get-join-keys clj/s

(get-join-keys node)

left-activate clj/s

(left-activate node join-bindings tokens memory transport listener)

left-retract clj/s

(left-retract node join-bindings tokens memory transport listener)

insert-facts! clj/s

(insert-facts! facts unconditional)

Place facts in a stateful cache to be inserted into the session immediately after the RHS of a rule fires.

IRightActivate clj/s≠ protocol

right-activate clj/s

(right-activate node join-bindings elements memory transport listener)

right-retract clj/s

(right-retract node join-bindings elements memory transport listener)

ISession clj/s≠ protocol

query clj/s

(query session query params)

fire-rules clj/s

(fire-rules session)

(fire-rules session opts)

insert clj/s

(insert session facts)

components clj/s

(components session)

retract clj/s

(retract session facts)

ITerminalNode clj/s≠ protocol

terminal-node-type clj/s

(terminal-node-type this)

ITransport clj/s≠ protocol

retract-elements clj/s

(retract-elements transport memory listener nodes elements)

retract-tokens clj/s

(retract-tokens transport memory listener nodes tokens)

send-elements clj/s

(send-elements transport memory listener nodes elements)

send-tokens clj/s

(send-tokens transport memory listener nodes tokens)

local-memory clj/s

(local-memory rulebase
              transport
              activation-group-sort-fn
              activation-group-fn
              alphas-fn)

Returns a local, in-process working memory.

LocalSession cljs

LocalTransport cljs

NegationNode cljs

NegationResult cljs

NegationWithJoinFilterNode cljs

node-rule-names clj/s

(node-rule-names child-type node)

options->activation-group-fn clj/s

(options->activation-group-fn options)

Given a map of options for a session, construct a function that takes a production and returns the activation group to which it belongs, considering both user-provided and internal salience. Under normal circumstances this function should only be called by Clara itself.

options->activation-group-sort-fn clj/s

(options->activation-group-sort-fn options)

Given the map of options for a session, construct an activation group sorting function that takes into account the user-provided salience and internal salience. User-provided salience is considered first. Under normal circumstances this function should only be called by Clara itself.

ProductionNode cljs

QueryNode cljs

remove-listeners clj/s

(remove-listeners session pred)

Return a new session with all listeners matching the predicate removed

retract-facts! clj/s

(retract-facts! facts)

Perform the fact retraction.

rhs-retract-facts! clj/s

(rhs-retract-facts! facts)

Place all facts retracted in the RHS in a buffer to be retracted after the eval'ed RHS function completes.

RootJoinNode cljs

TestNode cljs

Token cljs

variables-as-keywords clj/s

(variables-as-keywords expression)

Returns symbols in the given s-expression that start with '?' as keywords

with-listener clj/s

(with-listener session listener)

Return a new session with the listener added to the provided session, in addition to all listeners previously on the session.