use std::fmt;
use astrs_manifest::{DurationSecs, QueuePolicy};
use serde::{Deserialize, Serialize};
use crate::ids::{NodeId, PortName};
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
pub struct EdgeKey {
pub consumer: NodeId,
pub input: PortName,
}
impl EdgeKey {
#[must_use]
pub fn new(consumer: NodeId, input: PortName) -> Self {
Self { consumer, input }
}
}
impl fmt::Display for EdgeKey {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}.{}", self.consumer, self.input)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum EdgeSource {
NodeOutput {
node: NodeId,
output: PortName,
},
Virtual(String),
}
impl EdgeSource {
#[must_use]
pub fn producer_node(&self) -> Option<&NodeId> {
match self {
Self::NodeOutput { node, .. } => Some(node),
Self::Virtual(_) => None,
}
}
#[must_use]
pub fn is_virtual(&self) -> bool {
matches!(self, Self::Virtual(_))
}
}
impl fmt::Display for EdgeSource {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::NodeOutput { node, output } => write!(f, "{node}.{output}"),
Self::Virtual(source) => f.write_str(source),
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QueueConfig {
pub size: u32,
pub policy: QueuePolicy,
pub timeout: Option<DurationSecs>,
}
impl Default for QueueConfig {
fn default() -> Self {
Self {
size: astrs_manifest::default_queue_size(),
policy: QueuePolicy::default(),
timeout: None,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Edge {
pub from: EdgeSource,
pub queue: QueueConfig,
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
#[test]
fn edge_key_displays_dotted() {
let key = EdgeKey::new(NodeId::new("detector"), PortName::new("frames"));
assert_eq!(key.to_string(), "detector.frames");
}
#[test]
fn edge_key_orders_by_consumer_then_input() {
let a = EdgeKey::new(NodeId::new("a"), PortName::new("z"));
let b = EdgeKey::new(NodeId::new("b"), PortName::new("a"));
assert!(a < b);
}
#[test]
fn node_output_producer_node_is_some() {
let source = EdgeSource::NodeOutput {
node: NodeId::new("camera"),
output: PortName::new("frames"),
};
assert_eq!(source.producer_node(), Some(&NodeId::new("camera")));
assert!(!source.is_virtual());
assert_eq!(source.to_string(), "camera.frames");
}
#[test]
fn virtual_source_has_no_producer_node() {
let source = EdgeSource::Virtual("astrs/timer/hz/50".to_string());
assert_eq!(source.producer_node(), None);
assert!(source.is_virtual());
assert_eq!(source.to_string(), "astrs/timer/hz/50");
}
#[test]
fn queue_config_default_matches_manifest_default() {
let q = QueueConfig::default();
assert_eq!(q.size, 10);
assert_eq!(q.policy, QueuePolicy::DropOldest);
assert!(q.timeout.is_none());
}
#[test]
fn edge_is_cloneable_and_comparable() {
let e1 = Edge {
from: EdgeSource::Virtual("astrs/status".to_string()),
queue: QueueConfig::default(),
};
let e2 = e1.clone();
assert_eq!(e1, e2);
}
}