use super::{NodeStream, Row};
use std::rc::Rc;
pub type RelationshipStream = Rc<dyn Fn() -> NodeStream>;
#[derive(Clone)]
pub struct Node {
pub row: Row,
pub relationships: Relationships,
}
impl Node {
pub fn new(row: Row) -> Self {
Node {
row,
relationships: Relationships::default(),
}
}
pub fn with(mut self, name: &str, stream: RelationshipStream) -> Self {
self.relationships.set(name, Some(stream));
self
}
}
impl std::fmt::Debug for Node {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Node")
.field("row", &self.row)
.field("relationships", &self.relationships.names())
.finish()
}
}
#[derive(Clone, Default)]
pub struct Relationships {
entries: Vec<(String, RelationshipStream)>,
}
impl Relationships {
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
pub fn len(&self) -> usize {
self.entries.len()
}
pub fn names(&self) -> Vec<&str> {
self.entries.iter().map(|(n, _)| n.as_str()).collect()
}
pub fn get(&self, name: &str) -> Option<&RelationshipStream> {
self.entries.iter().find(|(n, _)| n == name).map(|(_, s)| s)
}
pub fn set(&mut self, name: &str, stream: Option<RelationshipStream>) {
let i = self.entries.iter().position(|(n, _)| n == name);
match (i, stream) {
(Some(i), Some(s)) => self.entries[i].1 = s,
(Some(i), None) => {
self.entries.remove(i);
}
(None, Some(s)) => self.entries.push((name.to_owned(), s)),
(None, None) => {}
}
}
pub fn merging(&self, other: &Relationships) -> Relationships {
let mut result = self.clone();
for (name, stream) in &other.entries {
result.set(name, Some(stream.clone()));
}
result
}
pub fn iter(&self) -> impl Iterator<Item = (&str, &RelationshipStream)> {
self.entries.iter().map(|(n, s)| (n.as_str(), s))
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ChangeType {
Add = 0,
Remove = 1,
Edit = 2,
Child = 3,
}
#[derive(Clone, Debug)]
pub struct ChildChange {
pub relationship_name: String,
pub change: Change,
}
#[derive(Clone, Debug)]
pub enum Change {
Add(Node),
Remove(Node),
Child(Node, Box<ChildChange>),
Edit { node: Node, old_node: Node },
}
impl Change {
pub fn change_type(&self) -> ChangeType {
match self {
Change::Add(_) => ChangeType::Add,
Change::Remove(_) => ChangeType::Remove,
Change::Child(..) => ChangeType::Child,
Change::Edit { .. } => ChangeType::Edit,
}
}
pub fn node(&self) -> &Node {
match self {
Change::Add(n) | Change::Remove(n) | Change::Child(n, _) => n,
Change::Edit { node, .. } => node,
}
}
pub fn child(node: Node, relationship_name: impl Into<String>, change: Change) -> Change {
Change::Child(
node,
Box::new(ChildChange {
relationship_name: relationship_name.into(),
change,
}),
)
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum SourceChange {
Add(Row),
Remove(Row),
Edit { row: Row, old_row: Row },
}
impl SourceChange {
pub fn change_type(&self) -> ChangeType {
match self {
SourceChange::Add(_) => ChangeType::Add,
SourceChange::Remove(_) => ChangeType::Remove,
SourceChange::Edit { .. } => ChangeType::Edit,
}
}
pub fn row(&self) -> &Row {
match self {
SourceChange::Add(r) | SourceChange::Remove(r) => r,
SourceChange::Edit { row, .. } => row,
}
}
}