use std::collections::{HashMap, HashSet};
use leptos::prelude::*;
use crate::types::*;
#[derive(Clone)]
pub struct NodeEntry<N: NodeId> {
pub id: N,
pub position: Position,
pub size: Size,
pub position_signal: Option<RwSignal<Position>>,
}
#[derive(Clone, Debug)]
pub struct PortEntry<N: NodeId, P: PortId, T: PortType> {
pub id: P,
pub node_id: N,
pub direction: PortDirection,
pub port_type: T,
pub position: Position,
pub slot_index: usize,
pub offset: Option<Position>,
}
#[derive(Clone, Debug)]
pub struct ConnectionEntry<P: PortId, C: ConnectionId> {
pub id: C,
pub source: P,
pub target: P,
}
#[derive(Clone, Debug)]
pub struct BoxSelect {
pub start: Position,
pub current: Position,
pub create_group: bool,
}
impl BoxSelect {
pub fn to_rect(&self) -> Rect {
let min_x = self.start.x.min(self.current.x);
let min_y = self.start.y.min(self.current.y);
let max_x = self.start.x.max(self.current.x);
let max_y = self.start.y.max(self.current.y);
Rect::new(min_x, min_y, max_x - min_x, max_y - min_y)
}
}
#[derive(Clone, Debug)]
pub struct DragState<N: NodeId> {
pub node_id: N,
pub offset: Position,
pub start_positions: HashMap<N, Position>,
pub alt_key: bool,
}
#[derive(Clone)]
pub struct ResizeState<N: NodeId> {
pub node_id: N,
pub start_x: f64,
pub start_width: f64,
pub width_signal: RwSignal<Option<f64>>,
pub min_width: f64,
pub max_width: Option<f64>,
}
#[derive(Clone)]
pub struct EditorRegistry<N, P, C, T>
where
N: NodeId,
P: PortId,
C: ConnectionId,
T: PortType,
{
pub nodes: RwSignal<HashMap<N, NodeEntry<N>>>,
pub live_positions: RwSignal<HashMap<N, Position>>,
pub ports: RwSignal<HashMap<P, PortEntry<N, P, T>>>,
pending_port_measurements: StoredValue<HashMap<P, (Position, Position)>>,
port_measurement_pending: StoredValue<bool>,
pub connections: RwSignal<HashMap<C, ConnectionEntry<P, C>>>,
pub selected_nodes: RwSignal<HashSet<N>>,
pub selected_connections: RwSignal<HashSet<C>>,
pub draft_connection: RwSignal<Option<DraftConnection<P, T>>>,
pub draft_origin: Memo<Option<(P, PortDirection)>>,
pub viewport: RwSignal<ViewportTransform>,
pub visibility_viewport: RwSignal<ViewportTransform>,
pub container_size: RwSignal<Size>,
pub config: RwSignal<EditorConfig>,
pub on_event: StoredValue<Callback<GraphEvent<N, P, C>>>,
pub box_select: RwSignal<Option<BoxSelect>>,
pub is_panning: RwSignal<bool>,
pub pan_origin: RwSignal<Option<Position>>,
pub menu_open: RwSignal<bool>,
pub drag_state: RwSignal<Option<DragState<N>>>,
pub resize_state: RwSignal<Option<ResizeState<N>>>,
pub pending_drag_pos: RwSignal<Option<Position>>,
pub drag_raf_pending: RwSignal<bool>,
}
impl<N, P, C, T> EditorRegistry<N, P, C, T>
where
N: NodeId,
P: PortId,
C: ConnectionId,
T: PortType,
{
pub fn new(config: EditorConfig, on_event: Callback<GraphEvent<N, P, C>>) -> Self {
let draft_connection: RwSignal<Option<DraftConnection<P, T>>> = RwSignal::new(None);
let draft_origin = Memo::new(move |_| {
draft_connection.with(|draft| {
draft
.as_ref()
.map(|draft| (draft.source_port.clone(), draft.origin_direction))
})
});
Self {
nodes: RwSignal::new(HashMap::new()),
live_positions: RwSignal::new(HashMap::new()),
ports: RwSignal::new(HashMap::new()),
pending_port_measurements: StoredValue::new(HashMap::new()),
port_measurement_pending: StoredValue::new(false),
connections: RwSignal::new(HashMap::new()),
selected_nodes: RwSignal::new(HashSet::new()),
selected_connections: RwSignal::new(HashSet::new()),
draft_connection,
draft_origin,
viewport: RwSignal::new(ViewportTransform::default()),
visibility_viewport: RwSignal::new(ViewportTransform::default()),
container_size: RwSignal::new(Size::default()),
config: RwSignal::new(config),
on_event: StoredValue::new(on_event),
box_select: RwSignal::new(None),
is_panning: RwSignal::new(false),
pan_origin: RwSignal::new(None),
menu_open: RwSignal::new(false),
drag_state: RwSignal::new(None),
resize_state: RwSignal::new(None),
pending_drag_pos: RwSignal::new(None),
drag_raf_pending: RwSignal::new(false),
}
}
pub fn emit(&self, event: GraphEvent<N, P, C>) {
self.on_event.with_value(|cb| cb.run(event));
}
pub fn register_node(
&self,
id: N,
position: Position,
position_signal: Option<RwSignal<Position>>,
) {
self.nodes.update(|nodes| {
nodes.insert(
id.clone(),
NodeEntry {
id: id.clone(),
position,
size: Size::default(),
position_signal,
},
);
});
self.live_positions.update(|positions| {
positions.insert(id, position);
});
}
pub fn deregister_node(&self, id: &N) {
let port_ids: Vec<P> = self.ports.with_untracked(|ports| {
ports
.values()
.filter(|entry| &entry.node_id == id)
.map(|entry| entry.id.clone())
.collect()
});
for port_id in port_ids {
self.deregister_port(&port_id);
}
self.nodes.update(|nodes| {
nodes.remove(id);
});
self.live_positions.update(|positions| {
positions.remove(id);
});
self.selected_nodes.update(|sel| {
sel.remove(id);
});
}
pub fn register_port(
&self,
id: P,
node_id: N,
direction: PortDirection,
port_type: T,
position: Position,
) {
self.ports.update(|ports| {
let next_idx = ports
.values()
.filter(|p| p.node_id == node_id && p.direction == direction)
.count();
for entry in ports.values_mut() {
if entry.node_id == node_id {
entry.offset = None;
}
}
ports.insert(
id.clone(),
PortEntry {
id,
node_id,
direction,
port_type,
position,
slot_index: next_idx,
offset: None,
},
);
});
}
pub fn deregister_port(&self, id: &P) {
self.pending_port_measurements.update_value(|updates| {
updates.remove(id);
});
let port_info = self
.ports
.with_untracked(|ports| ports.get(id).map(|p| (p.node_id.clone(), p.direction)));
self.ports.update(|ports| {
ports.remove(id);
if let Some((node_id, direction)) = &port_info {
let mut siblings: Vec<(usize, P)> = ports
.values()
.filter(|p| &p.node_id == node_id && p.direction == *direction)
.map(|p| (p.slot_index, p.id.clone()))
.collect();
siblings.sort_by_key(|(idx, _)| *idx);
for (new_idx, (_, port_id)) in siblings.into_iter().enumerate() {
if let Some(entry) = ports.get_mut(&port_id) {
entry.slot_index = new_idx;
entry.offset = None;
}
}
}
});
}
pub fn set_node_position(&self, id: &N, position: Position) {
self.nodes.maybe_update(|nodes| {
let Some(entry) = nodes.get_mut(id) else {
return false;
};
if entry.position == position {
return false;
}
entry.position = position;
true
});
self.live_positions.update(|positions| {
positions.insert(id.clone(), position);
});
}
pub fn set_node_position_with_signal(&self, id: &N, position: Position) {
let mut signal = None;
self.nodes.maybe_update(|nodes| {
let Some(entry) = nodes.get_mut(id) else {
return false;
};
signal = entry.position_signal;
if entry.position == position {
return false;
}
entry.position = position;
true
});
if let Some(signal) = signal
&& signal.get_untracked() != position
{
signal.set(position);
}
self.live_positions.update(|positions| {
positions.insert(id.clone(), position);
});
}
pub fn batch_set_positions(&self, updates: &[(N, Position)]) {
let mut node_signals = Vec::new();
let mut node_moves = HashMap::new();
self.nodes.maybe_update(|nodes| {
let mut changed = false;
for (id, position) in updates {
let Some(entry) = nodes.get_mut(id) else {
continue;
};
if entry.position == *position {
if let Some(signal) = entry.position_signal
&& signal.get_untracked() != *position
{
node_signals.push((signal, *position));
}
continue;
}
let delta =
Position::new(position.x - entry.position.x, position.y - entry.position.y);
entry.position = *position;
node_moves.insert(id.clone(), (*position, delta));
if let Some(signal) = entry.position_signal {
node_signals.push((signal, *position));
}
changed = true;
}
changed
});
self.ports.maybe_update(|ports| {
let mut changed = false;
for entry in ports.values_mut() {
let Some((new_node_position, delta)) = node_moves.get(&entry.node_id) else {
continue;
};
let position = match entry.offset {
Some(offset) => Position::new(
new_node_position.x + offset.x,
new_node_position.y + offset.y,
),
None => Position::new(entry.position.x + delta.x, entry.position.y + delta.y),
};
if entry.position != position {
entry.position = position;
changed = true;
}
}
changed
});
for (signal, position) in node_signals {
if signal.get_untracked() != position {
signal.set(position);
}
}
self.live_positions.update(|positions| {
for (id, position) in updates {
positions.insert(id.clone(), *position);
}
});
}
pub fn set_node_size(&self, id: &N, size: Size) {
self.nodes.maybe_update(|nodes| {
let Some(entry) = nodes.get_mut(id) else {
return false;
};
if entry.size == size {
return false;
}
entry.size = size;
true
});
}
pub fn set_port_position(&self, id: &P, position: Position) {
self.ports.maybe_update(|ports| {
let Some(entry) = ports.get_mut(id) else {
return false;
};
if entry.position == position {
return false;
}
entry.position = position;
true
});
}
pub(crate) fn queue_port_measurement(&self, id: P, position: Position, offset: Position) {
self.pending_port_measurements.update_value(|updates| {
updates.insert(id, (position, offset));
});
if self.port_measurement_pending.get_value() {
return;
}
self.port_measurement_pending.set_value(true);
let registry = self.clone();
crate::raf::request_animation_frame(move || registry.flush_port_measurements());
}
fn flush_port_measurements(&self) {
let Some(updates) = self
.pending_port_measurements
.try_update_value(std::mem::take)
else {
return; };
self.port_measurement_pending
.try_update_value(|pending| *pending = false);
self.nodes.with_untracked(|nodes| {
self.ports.try_maybe_update(|ports| {
let mut changed = false;
for (id, (position, offset)) in updates {
if let Some(port) = ports.get_mut(&id) {
let position = nodes.get(&port.node_id).map_or(position, |node| {
Position::new(node.position.x + offset.x, node.position.y + offset.y)
});
changed |= port.position != position;
port.position = position;
port.offset = Some(offset);
}
}
(changed, ())
});
});
}
pub fn set_port_offset(&self, id: &P, offset: Position) {
let mut guard = self.ports.write_untracked();
if let Some(entry) = guard.get_mut(id) {
entry.offset = Some(offset);
}
}
pub fn set_connections(&self, connections: HashMap<C, ConnectionEntry<P, C>>) {
self.connections.set(connections);
}
pub fn port_position(&self, id: &P) -> Option<Position> {
self.ports
.with_untracked(|ports| ports.get(id).map(|e| e.position))
}
pub fn get_port(&self, id: &P) -> Option<PortEntry<N, P, T>> {
self.ports.with_untracked(|ports| ports.get(id).cloned())
}
pub fn is_compatible_target(&self, target_id: &P) -> bool {
let draft = self.draft_connection.with_untracked(|d| d.clone());
let Some(draft) = draft else {
return false;
};
self.ports.with_untracked(|ports| {
let Some(target) = ports.get(target_id) else {
return false;
};
if target.direction != PortDirection::Input {
return false;
}
let Some(source) = ports.get(&draft.source_port) else {
return false;
};
if source.node_id == target.node_id {
return false;
}
T::compatible(&draft.port_type, &target.port_type)
})
}
pub fn select_node(&self, id: N) {
self.selected_connections.update(|sel| sel.clear());
self.selected_nodes.update(|sel| {
sel.clear();
sel.insert(id);
});
}
pub fn toggle_node_selection(&self, id: N) {
self.selected_nodes.update(|sel| {
if !sel.remove(&id) {
sel.insert(id);
}
});
}
pub fn select_connection(&self, id: C) {
self.selected_nodes.update(|sel| sel.clear());
self.selected_connections.update(|sel| {
sel.clear();
sel.insert(id);
});
}
pub fn clear_selection(&self) {
self.selected_nodes.update(|sel| sel.clear());
self.selected_connections.update(|sel| sel.clear());
}
pub fn select_all(&self) {
let all_ids: HashSet<N> = self
.nodes
.with_untracked(|nodes| nodes.keys().cloned().collect());
self.selected_nodes.set(all_ids);
}
pub fn delete_selected(&self) {
let selected_node_ids: Vec<N> = self
.selected_nodes
.with_untracked(|sel| sel.iter().cloned().collect());
let selected_conn_ids: Vec<C> = self
.selected_connections
.with_untracked(|sel| sel.iter().cloned().collect());
for conn_id in selected_conn_ids {
self.emit(GraphEvent::ConnectionRemoved { id: conn_id });
}
if !selected_node_ids.is_empty() {
self.emit(GraphEvent::NodesDeleted {
ids: selected_node_ids,
});
}
}
pub fn snap_target_for_draft(&self, cursor: Position, max_dist: f64) -> Option<(P, Position)> {
let draft = self.draft_connection.with_untracked(|d| d.clone())?;
let source = self.get_port(&draft.source_port)?;
let mut best: Option<(P, Position, f64)> = None;
self.ports.with_untracked(|ports| {
for entry in ports.values() {
if entry.direction == draft.origin_direction || entry.node_id == source.node_id {
continue;
}
let dist = crate::utils::distance(cursor, entry.position);
if dist > max_dist || best.as_ref().is_some_and(|(_, _, b)| dist >= *b) {
continue;
}
let (output_type, input_type) = if draft.origin_direction == PortDirection::Output {
(&source.port_type, &entry.port_type)
} else {
(&entry.port_type, &source.port_type)
};
if !T::compatible(output_type, input_type) {
continue;
}
best = Some((entry.id.clone(), entry.position, dist));
}
});
best.map(|(id, pos, _)| (id, pos))
}
pub fn nodes_bounds(&self) -> Option<Rect> {
self.nodes.with_untracked(|nodes| {
let mut entries = nodes.values();
let first = entries.next()?;
let (mut min_x, mut min_y) = (first.position.x, first.position.y);
let mut max_x = first.position.x + first.size.width;
let mut max_y = first.position.y + first.size.height;
for entry in entries {
min_x = min_x.min(entry.position.x);
min_y = min_y.min(entry.position.y);
max_x = max_x.max(entry.position.x + entry.size.width);
max_y = max_y.max(entry.position.y + entry.size.height);
}
Some(Rect::new(min_x, min_y, max_x - min_x, max_y - min_y))
})
}
pub fn fit_rect(&self, rect: &Rect, padding: f64, max_zoom_override: Option<f64>) {
let container = self.container_size.get_untracked();
if container.width <= 0.0 || container.height <= 0.0 {
return;
}
let width = rect.size.width.max(1.0);
let height = rect.size.height.max(1.0);
let avail_w = (container.width - 2.0 * padding).max(1.0);
let avail_h = (container.height - 2.0 * padding).max(1.0);
let (min_zoom, max_zoom) = self.config.with_untracked(|c| (c.min_zoom, c.max_zoom));
let ceiling = max_zoom_override.map_or(max_zoom, |m| m.min(max_zoom));
let zoom = (avail_w / width)
.min(avail_h / height)
.clamp(min_zoom, ceiling.max(min_zoom));
let center_x = rect.position.x + width / 2.0;
let center_y = rect.position.y + height / 2.0;
self.viewport.update(|vp| {
vp.zoom = zoom;
vp.pan_x = container.width / 2.0 - center_x * zoom;
vp.pan_y = container.height / 2.0 - center_y * zoom;
});
}
pub fn fit_view(&self) {
let Some(bounds) = self.nodes_bounds() else {
return;
};
let (padding, fit_max_zoom) = self
.config
.with_untracked(|c| (c.fit_padding, c.fit_max_zoom));
self.fit_rect(&bounds, padding, Some(fit_max_zoom));
}
pub fn nodes_in_rect(&self, rect: &Rect) -> HashSet<N> {
self.nodes.with_untracked(|nodes| {
nodes
.values()
.filter(|entry| {
let node_rect = Rect::new(
entry.position.x,
entry.position.y,
entry.size.width,
entry.size.height,
);
rect.intersects(&node_rect)
})
.map(|entry| entry.id.clone())
.collect()
})
}
}
#[cfg(test)]
mod tests {
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use super::*;
thread_local! { static COMPATIBILITY_CHECKS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; }
#[derive(Clone, Debug, PartialEq)]
enum TestPortType {
Any,
}
impl PortType for TestPortType {
fn compatible(_: &Self, _: &Self) -> bool {
COMPATIBILITY_CHECKS.with(|count| count.set(count.get() + 1));
true
}
fn type_id(&self) -> String {
"any".into()
}
fn from_type_id(_: &str) -> Self {
Self::Any
}
}
#[test]
fn measured_ports_publish_once_and_use_the_latest_node_position() {
Owner::new().with(|| {
let registry = EditorRegistry::<String, String, String, TestPortType>::new(
EditorConfig::default(),
Callback::new(|_: GraphEvent<String, String, String>| {}),
);
registry.register_node("node".into(), Position::default(), None);
for i in 0..835 {
registry.register_port(
i.to_string(),
"node".into(),
PortDirection::Input,
TestPortType::Any,
Position::default(),
);
}
let reads = Arc::new(AtomicUsize::new(0));
let count = reads.clone();
let ports = registry.ports;
let positions = Memo::new(move |_| {
count.fetch_add(1, Ordering::Relaxed);
ports.with(|ports| ports.values().map(|port| port.position.x).sum::<f64>())
});
assert_eq!(positions.get(), 0.0);
for i in 0..835 {
registry.pending_port_measurements.update_value(|updates| {
updates.insert(
i.to_string(),
(Position::new(5.0, 0.0), Position::new(5.0, 0.0)),
);
});
assert_eq!(positions.get(), 0.0);
}
assert_eq!(reads.load(Ordering::Relaxed), 1);
registry.set_node_position(&"node".into(), Position::new(10.0, 0.0));
let before = reads.load(Ordering::Relaxed);
registry.flush_port_measurements();
assert_eq!(positions.get(), 835.0 * 15.0);
assert_eq!(reads.load(Ordering::Relaxed), before + 1);
registry.flush_port_measurements();
assert_eq!(positions.get(), 835.0 * 15.0);
assert_eq!(reads.load(Ordering::Relaxed), before + 1);
assert!(registry.ports.with_untracked(|ports| {
ports
.values()
.all(|p| p.offset == Some(Position::new(5.0, 0.0)))
}));
});
}
#[test]
fn snapping_only_checks_types_within_the_pointer_radius() {
Owner::new().with(|| {
let registry = EditorRegistry::<String, String, String, TestPortType>::new(
EditorConfig::default(),
Callback::new(|_: GraphEvent<String, String, String>| {}),
);
registry.register_port(
"source".into(),
"origin".into(),
PortDirection::Output,
TestPortType::Any,
Position::default(),
);
for x in 0..1000 {
registry.register_port(
format!("far-{x}"),
"other".into(),
PortDirection::Input,
TestPortType::Any,
Position::new(1000.0 + x as f64, 0.0),
);
}
registry.register_port(
"near".into(),
"other".into(),
PortDirection::Input,
TestPortType::Any,
Position::new(2.0, 0.0),
);
registry.draft_connection.set(Some(DraftConnection {
source_port: "source".into(),
source_position: Position::default(),
port_type: TestPortType::Any,
current_end: Position::default(),
origin_direction: PortDirection::Output,
snap_target: None,
}));
COMPATIBILITY_CHECKS.with(|count| count.set(0));
assert_eq!(
registry.snap_target_for_draft(Position::default(), 10.0),
Some(("near".into(), Position::new(2.0, 0.0)))
);
COMPATIBILITY_CHECKS.with(|count| assert_eq!(count.get(), 1));
COMPATIBILITY_CHECKS.with(|count| count.set(0));
assert_eq!(
registry.snap_target_for_draft(Position::new(-100.0, 0.0), 10.0),
None
);
COMPATIBILITY_CHECKS.with(|count| assert_eq!(count.get(), 0));
});
}
#[test]
fn pointer_moves_do_not_recompute_draft_consumers() {
Owner::new().with(|| {
let registry = EditorRegistry::<String, String, String, TestPortType>::new(
EditorConfig::default(),
Callback::new(|_: GraphEvent<String, String, String>| {}),
);
let reads = Arc::new(AtomicUsize::new(0));
let count = reads.clone();
let origin = registry.draft_origin;
let anchor = Memo::new(move |_| {
count.fetch_add(1, Ordering::Relaxed);
origin.get()
});
assert_eq!(anchor.get(), None);
registry.draft_connection.set(Some(DraftConnection {
source_port: "source".into(),
source_position: Position::default(),
port_type: TestPortType::Any,
current_end: Position::default(),
origin_direction: PortDirection::Output,
snap_target: None,
}));
assert!(anchor.get().is_some());
let baseline = reads.load(Ordering::Relaxed);
for x in 0..100 {
registry.draft_connection.update(|draft| {
let draft = draft.as_mut().unwrap();
draft.current_end = Position::new(x as f64, 0.0);
draft.snap_target = Some(format!("target-{x}"));
});
assert!(anchor.get().is_some());
}
assert_eq!(reads.load(Ordering::Relaxed), baseline);
registry.draft_connection.set(None);
assert_eq!(anchor.get(), None);
assert_eq!(reads.load(Ordering::Relaxed), baseline + 1);
});
}
#[test]
fn geometry_writes_gate_noops_and_translate_offsetless_ports() {
Owner::new().with(|| {
let registry = EditorRegistry::<String, String, String, TestPortType>::new(
EditorConfig::default(),
Callback::new(|_: GraphEvent<String, String, String>| {}),
);
let position = Position::new(10.0, 20.0);
let position_signal = RwSignal::new(position);
let node_id = "node".to_string();
let port_id = "port".to_string();
let dynamic_port_id = "dynamic-port".to_string();
registry.register_node(node_id.clone(), position, Some(position_signal));
registry.register_port(
port_id.clone(),
node_id.clone(),
PortDirection::Output,
TestPortType::Any,
Position::new(30.0, 25.0),
);
registry.register_port(
dynamic_port_id.clone(),
node_id.clone(),
PortDirection::Output,
TestPortType::Any,
Position::new(50.0, 60.0),
);
registry.set_port_offset(&port_id, Position::new(20.0, 5.0));
let node_reads = Arc::new(AtomicUsize::new(0));
let node_reads_memo = Arc::clone(&node_reads);
let nodes = registry.nodes;
let node_geometry = Memo::new(move |_| {
node_reads_memo.fetch_add(1, Ordering::Relaxed);
nodes.with(|nodes| nodes.get("node").map(|node| (node.position, node.size)))
});
let port_reads = Arc::new(AtomicUsize::new(0));
let port_reads_memo = Arc::clone(&port_reads);
let ports = registry.ports;
let port_geometry = Memo::new(move |_| {
port_reads_memo.fetch_add(1, Ordering::Relaxed);
ports.with(|ports| {
Some((
ports.get("port")?.position,
ports.get("dynamic-port")?.position,
))
})
});
assert!(node_geometry.get().is_some());
assert!(port_geometry.get().is_some());
registry.set_node_position(&node_id, position);
registry.set_node_position_with_signal(&node_id, position);
registry.set_node_size(&node_id, Size::default());
registry.set_port_position(&port_id, Position::new(30.0, 25.0));
registry.batch_set_positions(&[("node".into(), position)]);
assert!(node_geometry.get().is_some());
assert!(port_geometry.get().is_some());
assert_eq!(node_reads.load(Ordering::Relaxed), 1);
assert_eq!(port_reads.load(Ordering::Relaxed), 1);
let moved = Position::new(20.0, 30.0);
registry.batch_set_positions(&[(node_id.clone(), moved)]);
assert_eq!(node_geometry.get(), Some((moved, Size::default())));
assert_eq!(
port_geometry.get(),
Some((Position::new(40.0, 35.0), Position::new(60.0, 70.0)))
);
assert_eq!(position_signal.get_untracked(), moved);
assert_eq!(node_reads.load(Ordering::Relaxed), 2);
assert_eq!(port_reads.load(Ordering::Relaxed), 2);
});
}
}