Struct TraversalEngine

Source

pub struct TraversalEngine { /* private fields */ }

Expand description

A budgeted star-graph traversal with accepted-subset tracking.

§Examples

use automation_structures::TraversalEngine;

let mut traversal = TraversalEngine::new(3, 0, 2)?;
traversal.visit(0)?;
assert!(traversal.is_visited(0));

Implementations§

Source §

impl TraversalEngine

Source

pub fn new( num_nodes: usize, root: usize, budget: u64, ) -> Result<Self, TraversalBuildError>

Construct a traversal rooted in the configured node universe.

§Errors

Returns an error when the node universe is empty or the root is outside it.

Examples found in repository ?

examples/catalog.rs (line 110)

21fn main() -> Result<(), Box<dyn Error>> {
22    // Primitives.
23    let mut budget = Budget::new(8);
24    assert!(budget.try_reserve(3));
25    budget.commit_reservation(3)?;
26
27    let mut hierarchy = QualityHierarchy::new(2, 2);
28    hierarchy.set_node_properties(0, 2, 1)?;
29    hierarchy.set_node_properties(1, 1, 2)?;
30    hierarchy.add_child(0, 1)?;
31
32    let mut registry = ResourceRegistry::new();
33    registry.insert(1, 10);
34    assert_eq!(registry.get(1), Some(10));
35
36    let mut hard = CompetitiveSelectionHard::new(2)?;
37    hard.update_score(0, 2)?;
38    hard.update_score(1, 1)?;
39    assert_eq!(hard.evaluate(), 0);
40
41    let mut exclusive = CompetitiveSelectionHardExclusive::new(1, 2, 2)?;
42    exclusive.update_score(0, 0, 2)?;
43    exclusive.update_score(0, 1, 1)?;
44    assert_eq!(exclusive.evaluate(0)?, 0);
45
46    let mut soft = CompetitiveSelectionSoft::begin(vec![3, 1], 4, 3)?;
47    assert_eq!(soft.assign_next()?, 0);
48
49    let mut ranked = CompetitiveSelectionRanked::new(vec![2, 1], 1, 2)?;
50    ranked.select();
51    assert_eq!(ranked.is_selected(0), Some(true));
52
53    let mut actuation = ActuationPass::new(vec![Some(7)]);
54    actuation.actuate(0)?;
55    actuation.finish()?;
56
57    let mut propagation = PropagationPass::new(1, 2, vec![], vec![0])?;
58    propagation.start_round()?;
59    propagation.update_node(0)?;
60    propagation.end_round()?;
61
62    let mut convergence = ConvergenceGovernor::new(2, 6, 2, 10)?;
63    assert_eq!(convergence.update(1)?, 1);
64
65    let mut audit = AuditSink::new(1);
66    assert!(audit.try_record(7));
67    assert!(audit.validate());
68
69    let mut backtracking = BacktrackingTraversal::new(2, 1, 0)?;
70    backtracking.descend(1, 1)?;
71    backtracking.visit()?;
72
73    // Named compositions.
74    let mut snapshot = AllocationSnapshot::new(3, 1);
75    snapshot.accept(0, 3)?;
76
77    let mut federated = FederatedBudget::new(4, 1);
78    assert!(federated.try_delegate(0, 4));
79    assert!(federated.try_allocate(0, 2));
80
81    let mut bisection = Bisection::new(4, 2)?;
82    bisection.converge();
83    assert!(bisection.is_converged());
84
85    let mut classes = EquivalenceClass::new(2, 1);
86    assert!(classes.union(0, 1)?);
87
88    let mut rate_limit = RateLimit::new(1, 1, 1)?;
89    assert!(rate_limit.try_acquire());
90
91    let mut reduction = Reduction::new(vec![2, 3])?;
92    reduction.process_next()?;
93
94    let mut graph = RelationshipGraph::new(2, 1);
95    assert!(graph.add_edge(0, 1, 1)?);
96
97    let mut sampler = Sampler::new(vec![1, 1], 1);
98    sampler.sample(0)?;
99
100    let mut select_then_actuate = SelectThenActuate::new(1, 2)?;
101    select_then_actuate.update_score(0, 0, 1)?;
102    assert_eq!(select_then_actuate.evaluate(0)?, 0);
103    select_then_actuate.actuate(0)?;
104    select_then_actuate.finish()?;
105
106    let mut signal = Signal::new(0, 2, 1)?;
107    assert!(signal.set_value(1)?);
108    signal.notify(0)?;
109
110    let mut traversal = TraversalEngine::new(1, 0, 2)?;
111    traversal.visit(0)?;
112    assert_eq!(traversal.accepted_cost(), 2);
113    traversal.terminate()?;
114
115    // Execution modalities.
116    let mut sequential = Sequential::new(1, 2, 0)?;
117    assert!(sequential.begin_step());
118    assert!(sequential.complete_step(1));
119
120    let mut fork_join = ForkJoin::new(1, 2, 0)?;
121    assert!(fork_join.start_worker(0));
122    assert!(fork_join.complete_worker(0, 1));
123    assert!(fork_join.barrier());
124    assert!(fork_join.produce_output());
125
126    let mut step_graph = StepGraph::new(1, vec![])?;
127    assert!(step_graph.start(0));
128    assert!(step_graph.complete(0));
129
130    let mut stream_graph = StreamGraph::new(3, 1, 1, 2)?;
131    assert!(stream_graph.ingest(1));
132    assert!(stream_graph.advance_first());
133    assert_eq!(stream_graph.consume(), Some(1));
134
135    // Connective roles.
136    let mut cursor = Cursor::new(0);
137    cursor.advance_to(1)?;
138
139    let mut accumulator = Accumulator::new(vec![1]);
140    assert_eq!(accumulator.advance(), Some(1));
141    assert_eq!(accumulator.accumulated(0), Some(1));
142
143    let mut marker = Marker::new(false);
144    assert!(marker.set());
145
146    let mut counter = Counter::new(0);
147    assert!(counter.try_increment());
148
149    let mut buffer = Buffer::new(1);
150    assert_eq!(buffer.push(1), Ok(()));
151    assert_eq!(buffer.pop(), Some(1));
152
153    assert!(projection_consistent(true, true));
154    assert!(strictly_before(0, 1));
155
156    assert_debuggable!(
157        budget,
158        hierarchy,
159        registry,
160        hard,
161        exclusive,
162        soft,
163        ranked,
164        actuation,
165        propagation,
166        convergence,
167        audit,
168        backtracking,
169        snapshot,
170        federated,
171        bisection,
172        classes,
173        rate_limit,
174        reduction,
175        graph,
176        sampler,
177        select_then_actuate,
178        signal,
179        traversal,
180        sequential,
181        fork_join,
182        step_graph,
183        stream_graph,
184        cursor,
185        accumulator,
186        marker,
187        counter,
188        buffer,
189    );
190
191    println!("all public automation structures constructed and exercised");
192    Ok(())
193}

Source

pub fn num_nodes(&self) -> usize

Number of nodes.

Source

pub fn root(&self) -> usize

Traversal root.

Source

pub fn budget_remaining(&self) -> u64

Remaining traversal budget.

Source

pub fn queued_len(&self) -> usize

Number of queued nodes.

Source

pub fn visited_len(&self) -> usize

Number of visited nodes.

Source

pub fn accepted_len(&self) -> usize

Number of budget-accepted nodes.

Source

pub fn accepted_cost(&self) -> u64

Total cost committed for budget-accepted nodes.

Examples found in repository ?

examples/catalog.rs (line 112)

21fn main() -> Result<(), Box<dyn Error>> {
22    // Primitives.
23    let mut budget = Budget::new(8);
24    assert!(budget.try_reserve(3));
25    budget.commit_reservation(3)?;
26
27    let mut hierarchy = QualityHierarchy::new(2, 2);
28    hierarchy.set_node_properties(0, 2, 1)?;
29    hierarchy.set_node_properties(1, 1, 2)?;
30    hierarchy.add_child(0, 1)?;
31
32    let mut registry = ResourceRegistry::new();
33    registry.insert(1, 10);
34    assert_eq!(registry.get(1), Some(10));
35
36    let mut hard = CompetitiveSelectionHard::new(2)?;
37    hard.update_score(0, 2)?;
38    hard.update_score(1, 1)?;
39    assert_eq!(hard.evaluate(), 0);
40
41    let mut exclusive = CompetitiveSelectionHardExclusive::new(1, 2, 2)?;
42    exclusive.update_score(0, 0, 2)?;
43    exclusive.update_score(0, 1, 1)?;
44    assert_eq!(exclusive.evaluate(0)?, 0);
45
46    let mut soft = CompetitiveSelectionSoft::begin(vec![3, 1], 4, 3)?;
47    assert_eq!(soft.assign_next()?, 0);
48
49    let mut ranked = CompetitiveSelectionRanked::new(vec![2, 1], 1, 2)?;
50    ranked.select();
51    assert_eq!(ranked.is_selected(0), Some(true));
52
53    let mut actuation = ActuationPass::new(vec![Some(7)]);
54    actuation.actuate(0)?;
55    actuation.finish()?;
56
57    let mut propagation = PropagationPass::new(1, 2, vec![], vec![0])?;
58    propagation.start_round()?;
59    propagation.update_node(0)?;
60    propagation.end_round()?;
61
62    let mut convergence = ConvergenceGovernor::new(2, 6, 2, 10)?;
63    assert_eq!(convergence.update(1)?, 1);
64
65    let mut audit = AuditSink::new(1);
66    assert!(audit.try_record(7));
67    assert!(audit.validate());
68
69    let mut backtracking = BacktrackingTraversal::new(2, 1, 0)?;
70    backtracking.descend(1, 1)?;
71    backtracking.visit()?;
72
73    // Named compositions.
74    let mut snapshot = AllocationSnapshot::new(3, 1);
75    snapshot.accept(0, 3)?;
76
77    let mut federated = FederatedBudget::new(4, 1);
78    assert!(federated.try_delegate(0, 4));
79    assert!(federated.try_allocate(0, 2));
80
81    let mut bisection = Bisection::new(4, 2)?;
82    bisection.converge();
83    assert!(bisection.is_converged());
84
85    let mut classes = EquivalenceClass::new(2, 1);
86    assert!(classes.union(0, 1)?);
87
88    let mut rate_limit = RateLimit::new(1, 1, 1)?;
89    assert!(rate_limit.try_acquire());
90
91    let mut reduction = Reduction::new(vec![2, 3])?;
92    reduction.process_next()?;
93
94    let mut graph = RelationshipGraph::new(2, 1);
95    assert!(graph.add_edge(0, 1, 1)?);
96
97    let mut sampler = Sampler::new(vec![1, 1], 1);
98    sampler.sample(0)?;
99
100    let mut select_then_actuate = SelectThenActuate::new(1, 2)?;
101    select_then_actuate.update_score(0, 0, 1)?;
102    assert_eq!(select_then_actuate.evaluate(0)?, 0);
103    select_then_actuate.actuate(0)?;
104    select_then_actuate.finish()?;
105
106    let mut signal = Signal::new(0, 2, 1)?;
107    assert!(signal.set_value(1)?);
108    signal.notify(0)?;
109
110    let mut traversal = TraversalEngine::new(1, 0, 2)?;
111    traversal.visit(0)?;
112    assert_eq!(traversal.accepted_cost(), 2);
113    traversal.terminate()?;
114
115    // Execution modalities.
116    let mut sequential = Sequential::new(1, 2, 0)?;
117    assert!(sequential.begin_step());
118    assert!(sequential.complete_step(1));
119
120    let mut fork_join = ForkJoin::new(1, 2, 0)?;
121    assert!(fork_join.start_worker(0));
122    assert!(fork_join.complete_worker(0, 1));
123    assert!(fork_join.barrier());
124    assert!(fork_join.produce_output());
125
126    let mut step_graph = StepGraph::new(1, vec![])?;
127    assert!(step_graph.start(0));
128    assert!(step_graph.complete(0));
129
130    let mut stream_graph = StreamGraph::new(3, 1, 1, 2)?;
131    assert!(stream_graph.ingest(1));
132    assert!(stream_graph.advance_first());
133    assert_eq!(stream_graph.consume(), Some(1));
134
135    // Connective roles.
136    let mut cursor = Cursor::new(0);
137    cursor.advance_to(1)?;
138
139    let mut accumulator = Accumulator::new(vec![1]);
140    assert_eq!(accumulator.advance(), Some(1));
141    assert_eq!(accumulator.accumulated(0), Some(1));
142
143    let mut marker = Marker::new(false);
144    assert!(marker.set());
145
146    let mut counter = Counter::new(0);
147    assert!(counter.try_increment());
148
149    let mut buffer = Buffer::new(1);
150    assert_eq!(buffer.push(1), Ok(()));
151    assert_eq!(buffer.pop(), Some(1));
152
153    assert!(projection_consistent(true, true));
154    assert!(strictly_before(0, 1));
155
156    assert_debuggable!(
157        budget,
158        hierarchy,
159        registry,
160        hard,
161        exclusive,
162        soft,
163        ranked,
164        actuation,
165        propagation,
166        convergence,
167        audit,
168        backtracking,
169        snapshot,
170        federated,
171        bisection,
172        classes,
173        rate_limit,
174        reduction,
175        graph,
176        sampler,
177        select_then_actuate,
178        signal,
179        traversal,
180        sequential,
181        fork_join,
182        step_graph,
183        stream_graph,
184        cursor,
185        accumulator,
186        marker,
187        counter,
188        buffer,
189    );
190
191    println!("all public automation structures constructed and exercised");
192    Ok(())
193}

Source

pub fn is_queued(&self, node: usize) -> bool

Whether a node is queued.

Source

pub fn is_visited(&self, node: usize) -> bool

Whether a node was visited.

Source

pub fn is_accepted(&self, node: usize) -> bool

Whether a node was accepted under the budget.

Source

pub fn visit(&mut self, node: usize) -> Result<(), TraversalError>

Visit one queued, unvisited node.

§Errors

Returns an error when the node is unknown, not queued, or already visited.

Examples found in repository ?

examples/catalog.rs (line 111)

21fn main() -> Result<(), Box<dyn Error>> {
22    // Primitives.
23    let mut budget = Budget::new(8);
24    assert!(budget.try_reserve(3));
25    budget.commit_reservation(3)?;
26
27    let mut hierarchy = QualityHierarchy::new(2, 2);
28    hierarchy.set_node_properties(0, 2, 1)?;
29    hierarchy.set_node_properties(1, 1, 2)?;
30    hierarchy.add_child(0, 1)?;
31
32    let mut registry = ResourceRegistry::new();
33    registry.insert(1, 10);
34    assert_eq!(registry.get(1), Some(10));
35
36    let mut hard = CompetitiveSelectionHard::new(2)?;
37    hard.update_score(0, 2)?;
38    hard.update_score(1, 1)?;
39    assert_eq!(hard.evaluate(), 0);
40
41    let mut exclusive = CompetitiveSelectionHardExclusive::new(1, 2, 2)?;
42    exclusive.update_score(0, 0, 2)?;
43    exclusive.update_score(0, 1, 1)?;
44    assert_eq!(exclusive.evaluate(0)?, 0);
45
46    let mut soft = CompetitiveSelectionSoft::begin(vec![3, 1], 4, 3)?;
47    assert_eq!(soft.assign_next()?, 0);
48
49    let mut ranked = CompetitiveSelectionRanked::new(vec![2, 1], 1, 2)?;
50    ranked.select();
51    assert_eq!(ranked.is_selected(0), Some(true));
52
53    let mut actuation = ActuationPass::new(vec![Some(7)]);
54    actuation.actuate(0)?;
55    actuation.finish()?;
56
57    let mut propagation = PropagationPass::new(1, 2, vec![], vec![0])?;
58    propagation.start_round()?;
59    propagation.update_node(0)?;
60    propagation.end_round()?;
61
62    let mut convergence = ConvergenceGovernor::new(2, 6, 2, 10)?;
63    assert_eq!(convergence.update(1)?, 1);
64
65    let mut audit = AuditSink::new(1);
66    assert!(audit.try_record(7));
67    assert!(audit.validate());
68
69    let mut backtracking = BacktrackingTraversal::new(2, 1, 0)?;
70    backtracking.descend(1, 1)?;
71    backtracking.visit()?;
72
73    // Named compositions.
74    let mut snapshot = AllocationSnapshot::new(3, 1);
75    snapshot.accept(0, 3)?;
76
77    let mut federated = FederatedBudget::new(4, 1);
78    assert!(federated.try_delegate(0, 4));
79    assert!(federated.try_allocate(0, 2));
80
81    let mut bisection = Bisection::new(4, 2)?;
82    bisection.converge();
83    assert!(bisection.is_converged());
84
85    let mut classes = EquivalenceClass::new(2, 1);
86    assert!(classes.union(0, 1)?);
87
88    let mut rate_limit = RateLimit::new(1, 1, 1)?;
89    assert!(rate_limit.try_acquire());
90
91    let mut reduction = Reduction::new(vec![2, 3])?;
92    reduction.process_next()?;
93
94    let mut graph = RelationshipGraph::new(2, 1);
95    assert!(graph.add_edge(0, 1, 1)?);
96
97    let mut sampler = Sampler::new(vec![1, 1], 1);
98    sampler.sample(0)?;
99
100    let mut select_then_actuate = SelectThenActuate::new(1, 2)?;
101    select_then_actuate.update_score(0, 0, 1)?;
102    assert_eq!(select_then_actuate.evaluate(0)?, 0);
103    select_then_actuate.actuate(0)?;
104    select_then_actuate.finish()?;
105
106    let mut signal = Signal::new(0, 2, 1)?;
107    assert!(signal.set_value(1)?);
108    signal.notify(0)?;
109
110    let mut traversal = TraversalEngine::new(1, 0, 2)?;
111    traversal.visit(0)?;
112    assert_eq!(traversal.accepted_cost(), 2);
113    traversal.terminate()?;
114
115    // Execution modalities.
116    let mut sequential = Sequential::new(1, 2, 0)?;
117    assert!(sequential.begin_step());
118    assert!(sequential.complete_step(1));
119
120    let mut fork_join = ForkJoin::new(1, 2, 0)?;
121    assert!(fork_join.start_worker(0));
122    assert!(fork_join.complete_worker(0, 1));
123    assert!(fork_join.barrier());
124    assert!(fork_join.produce_output());
125
126    let mut step_graph = StepGraph::new(1, vec![])?;
127    assert!(step_graph.start(0));
128    assert!(step_graph.complete(0));
129
130    let mut stream_graph = StreamGraph::new(3, 1, 1, 2)?;
131    assert!(stream_graph.ingest(1));
132    assert!(stream_graph.advance_first());
133    assert_eq!(stream_graph.consume(), Some(1));
134
135    // Connective roles.
136    let mut cursor = Cursor::new(0);
137    cursor.advance_to(1)?;
138
139    let mut accumulator = Accumulator::new(vec![1]);
140    assert_eq!(accumulator.advance(), Some(1));
141    assert_eq!(accumulator.accumulated(0), Some(1));
142
143    let mut marker = Marker::new(false);
144    assert!(marker.set());
145
146    let mut counter = Counter::new(0);
147    assert!(counter.try_increment());
148
149    let mut buffer = Buffer::new(1);
150    assert_eq!(buffer.push(1), Ok(()));
151    assert_eq!(buffer.pop(), Some(1));
152
153    assert!(projection_consistent(true, true));
154    assert!(strictly_before(0, 1));
155
156    assert_debuggable!(
157        budget,
158        hierarchy,
159        registry,
160        hard,
161        exclusive,
162        soft,
163        ranked,
164        actuation,
165        propagation,
166        convergence,
167        audit,
168        backtracking,
169        snapshot,
170        federated,
171        bisection,
172        classes,
173        rate_limit,
174        reduction,
175        graph,
176        sampler,
177        select_then_actuate,
178        signal,
179        traversal,
180        sequential,
181        fork_join,
182        step_graph,
183        stream_graph,
184        cursor,
185        accumulator,
186        marker,
187        counter,
188        buffer,
189    );
190
191    println!("all public automation structures constructed and exercised");
192    Ok(())
193}

Source

pub fn skip(&mut self, node: usize) -> Result<(), TraversalError>

Remove one queued node without visiting it.

§Errors

Returns an error when the node is unknown, not queued, or already visited.

Source

pub fn terminate(&mut self) -> Result<(), TraversalError>

Confirm the terminal stutter when no queued work remains.

§Errors

Returns TraversalError::QueueNotEmpty while work remains queued.

Examples found in repository ?

examples/catalog.rs (line 113)

21fn main() -> Result<(), Box<dyn Error>> {
22    // Primitives.
23    let mut budget = Budget::new(8);
24    assert!(budget.try_reserve(3));
25    budget.commit_reservation(3)?;
26
27    let mut hierarchy = QualityHierarchy::new(2, 2);
28    hierarchy.set_node_properties(0, 2, 1)?;
29    hierarchy.set_node_properties(1, 1, 2)?;
30    hierarchy.add_child(0, 1)?;
31
32    let mut registry = ResourceRegistry::new();
33    registry.insert(1, 10);
34    assert_eq!(registry.get(1), Some(10));
35
36    let mut hard = CompetitiveSelectionHard::new(2)?;
37    hard.update_score(0, 2)?;
38    hard.update_score(1, 1)?;
39    assert_eq!(hard.evaluate(), 0);
40
41    let mut exclusive = CompetitiveSelectionHardExclusive::new(1, 2, 2)?;
42    exclusive.update_score(0, 0, 2)?;
43    exclusive.update_score(0, 1, 1)?;
44    assert_eq!(exclusive.evaluate(0)?, 0);
45
46    let mut soft = CompetitiveSelectionSoft::begin(vec![3, 1], 4, 3)?;
47    assert_eq!(soft.assign_next()?, 0);
48
49    let mut ranked = CompetitiveSelectionRanked::new(vec![2, 1], 1, 2)?;
50    ranked.select();
51    assert_eq!(ranked.is_selected(0), Some(true));
52
53    let mut actuation = ActuationPass::new(vec![Some(7)]);
54    actuation.actuate(0)?;
55    actuation.finish()?;
56
57    let mut propagation = PropagationPass::new(1, 2, vec![], vec![0])?;
58    propagation.start_round()?;
59    propagation.update_node(0)?;
60    propagation.end_round()?;
61
62    let mut convergence = ConvergenceGovernor::new(2, 6, 2, 10)?;
63    assert_eq!(convergence.update(1)?, 1);
64
65    let mut audit = AuditSink::new(1);
66    assert!(audit.try_record(7));
67    assert!(audit.validate());
68
69    let mut backtracking = BacktrackingTraversal::new(2, 1, 0)?;
70    backtracking.descend(1, 1)?;
71    backtracking.visit()?;
72
73    // Named compositions.
74    let mut snapshot = AllocationSnapshot::new(3, 1);
75    snapshot.accept(0, 3)?;
76
77    let mut federated = FederatedBudget::new(4, 1);
78    assert!(federated.try_delegate(0, 4));
79    assert!(federated.try_allocate(0, 2));
80
81    let mut bisection = Bisection::new(4, 2)?;
82    bisection.converge();
83    assert!(bisection.is_converged());
84
85    let mut classes = EquivalenceClass::new(2, 1);
86    assert!(classes.union(0, 1)?);
87
88    let mut rate_limit = RateLimit::new(1, 1, 1)?;
89    assert!(rate_limit.try_acquire());
90
91    let mut reduction = Reduction::new(vec![2, 3])?;
92    reduction.process_next()?;
93
94    let mut graph = RelationshipGraph::new(2, 1);
95    assert!(graph.add_edge(0, 1, 1)?);
96
97    let mut sampler = Sampler::new(vec![1, 1], 1);
98    sampler.sample(0)?;
99
100    let mut select_then_actuate = SelectThenActuate::new(1, 2)?;
101    select_then_actuate.update_score(0, 0, 1)?;
102    assert_eq!(select_then_actuate.evaluate(0)?, 0);
103    select_then_actuate.actuate(0)?;
104    select_then_actuate.finish()?;
105
106    let mut signal = Signal::new(0, 2, 1)?;
107    assert!(signal.set_value(1)?);
108    signal.notify(0)?;
109
110    let mut traversal = TraversalEngine::new(1, 0, 2)?;
111    traversal.visit(0)?;
112    assert_eq!(traversal.accepted_cost(), 2);
113    traversal.terminate()?;
114
115    // Execution modalities.
116    let mut sequential = Sequential::new(1, 2, 0)?;
117    assert!(sequential.begin_step());
118    assert!(sequential.complete_step(1));
119
120    let mut fork_join = ForkJoin::new(1, 2, 0)?;
121    assert!(fork_join.start_worker(0));
122    assert!(fork_join.complete_worker(0, 1));
123    assert!(fork_join.barrier());
124    assert!(fork_join.produce_output());
125
126    let mut step_graph = StepGraph::new(1, vec![])?;
127    assert!(step_graph.start(0));
128    assert!(step_graph.complete(0));
129
130    let mut stream_graph = StreamGraph::new(3, 1, 1, 2)?;
131    assert!(stream_graph.ingest(1));
132    assert!(stream_graph.advance_first());
133    assert_eq!(stream_graph.consume(), Some(1));
134
135    // Connective roles.
136    let mut cursor = Cursor::new(0);
137    cursor.advance_to(1)?;
138
139    let mut accumulator = Accumulator::new(vec![1]);
140    assert_eq!(accumulator.advance(), Some(1));
141    assert_eq!(accumulator.accumulated(0), Some(1));
142
143    let mut marker = Marker::new(false);
144    assert!(marker.set());
145
146    let mut counter = Counter::new(0);
147    assert!(counter.try_increment());
148
149    let mut buffer = Buffer::new(1);
150    assert_eq!(buffer.push(1), Ok(()));
151    assert_eq!(buffer.pop(), Some(1));
152
153    assert!(projection_consistent(true, true));
154    assert!(strictly_before(0, 1));
155
156    assert_debuggable!(
157        budget,
158        hierarchy,
159        registry,
160        hard,
161        exclusive,
162        soft,
163        ranked,
164        actuation,
165        propagation,
166        convergence,
167        audit,
168        backtracking,
169        snapshot,
170        federated,
171        bisection,
172        classes,
173        rate_limit,
174        reduction,
175        graph,
176        sampler,
177        select_then_actuate,
178        signal,
179        traversal,
180        sequential,
181        fork_join,
182        step_graph,
183        stream_graph,
184        cursor,
185        accumulator,
186        marker,
187        counter,
188        buffer,
189    );
190
191    println!("all public automation structures constructed and exercised");
192    Ok(())
193}