Returns all steps with the state :error for a given state vector v

Handles the case where all state interfaces in a container are :executed. Proceeds depending on the old value of the ctrl interface.

Returns all-executed entrys of the given vector v.

Example:

  (all-executed (stu/seq-idx->all-par
                    [{:seq-idx 0 :par-idx 0 :state :executed}
                     {:seq-idx 0 :par-idx 0 :state :ready}]
                   0))
;; =>
;; [{:seq-idx 0 :par-idx 0 :state :executed}]

Checks if all entries of map m are executed

Returns all steps with the state :ready for a given state vector v

Gets the cmd from the ctrl-k. Extracts the next-ctrl-cmd and make a keyword out of it.

Opposite of observe!: De-registers the state listener. The de-register pattern is derived from the key k (may be the ctrl-key or state-key). Resets the state interface afterwards.

observe!s or de-observe!s depending on cmd. If an :error occurs the system is kept running (no de-observe). So, no restart is necessary. Just fix the problem and set the corresponding state from :error to ready and the processing goes on.

Sets the ctrl interface to "error". Function does not de-observe!.

Checks if there are any errors in the vector of maps v.

Returns a vector of maps where state is s.

Returns the state keys for a given path.

(k->state-ks "wait@container@0")

Builds the state map m belonging to a key set ks. m is introduced in order to keep the functions testable.

Example:

(ks->state-vec (k->state-ks "ref@container@0"))

The next-map function returns a map containing the next step to start. See cmp.state-test/next-map-i for examples how next-map should work.

Example:

 (next-map [{:seq-idx 0 :par-idx 0 :state :executed}
            {:seq-idx 0 :par-idx 1 :state :executed}
            {:seq-idx 1 :par-idx 0 :state :executed}
            {:seq-idx 2 :par-idx 0 :state :executed}
            {:seq-idx 3 :par-idx 0 :state :working}
            {:seq-idx 3 :par-idx 1 :state :ready}])
;; =>
;; {:seq-idx 3 :par-idx 1 :state :ready}

Returns a map (or nil) with the next step with state :ready.

Registers a listener for the state-interface of a container or definitions struct. start-next! is the callback of this listener. The register pattern is derived from the key k (ctrl-key).

Checks if the steps of v before i are all-executed?. Returns true for i equal to zero (or negative i)

Sets all states (the state interface) to ready.

Registers a listener for the ctrl interface of the entire mp-id. The dispatch function becomes the listeners cb!.

Side effect free. Makes start-next! testable. Gets the state vector v and picks the next thing to do. The ctrl-key is derived from the first map in the the v.

start-next! choose the k of the upcomming tasks. Then the worker set the state to "working" which triggers the next call to start-next!: parallel tasks are started this way.

Side effects all around.

Builds a state-map by means of the info-map. The state value is assoced afet getting it with st/key->val.

De-registers the listener for the ctrl interfaces of the mp-id. After stopping, the system will no longer react on changes (write events) at the ctrl interface.