use euclid::default::Point2D;
use petgraph::Direction;
use petgraph::visit::{EdgeRef, IntoEdgeReferences};
use uuid::Uuid;
use crate::types::GraphScope;
use super::edge_data::Traversal;
use super::edge_data::{SemanticStatement, SemanticStatementSpec, StatementAssert};
use super::edge_payload::EdgePayload;
use super::edge_taxonomy::{EdgeAssertion, RelationSelector, SemanticSubKind};
use super::identity::{EdgeKey, NodeKey};
use super::{DissolvedTraversalRecord, Graph};
impl Graph {
pub(crate) fn assert_relation(
&mut self,
from: NodeKey,
to: NodeKey,
assertion: EdgeAssertion,
) -> Option<EdgeKey> {
if let EdgeAssertion::Semantic {
sub_kind,
label,
decay_progress: _,
} = assertion
{
return self.assert_semantic_relation_in_scope(
from,
to,
sub_kind,
label,
GraphScope::Default,
);
}
if !self.inner.contains_node(from) || !self.inner.contains_node(to) {
return None;
}
if let Some(edge_key) = self.find_edge_key(from, to) {
let changed = {
let payload = self.inner.edge_mut(edge_key)?;
payload.assert_relation(assertion)
};
if changed {
self.bump_revision();
return Some(edge_key);
}
return None;
}
let mut payload = EdgePayload::new();
if !payload.assert_relation(assertion) {
return None;
}
let edge_key = self.inner.connect(from, to, payload);
self.bump_revision();
Some(edge_key)
}
pub(crate) fn assert_semantic_relation_in_scope(
&mut self,
from: NodeKey,
to: NodeKey,
sub_kind: SemanticSubKind,
label: Option<String>,
graph_scope: GraphScope,
) -> Option<EdgeKey> {
if !self.inner.contains_node(from) || !self.inner.contains_node(to) {
return None;
}
let edge_key = self
.find_edge_key(from, to)
.unwrap_or_else(|| self.inner.connect(from, to, EdgePayload::new()));
let changed = {
let payload = self.inner.edge_mut(edge_key)?;
payload.assert_semantic_relation_in_scope(sub_kind, label, graph_scope)
};
if changed {
self.bump_revision();
return Some(edge_key);
}
None
}
pub(crate) fn assert_semantic_predicate(
&mut self,
from: NodeKey,
to: NodeKey,
predicate: String,
) -> Option<EdgeKey> {
self.assert_semantic_predicate_in_scope(from, to, predicate, GraphScope::Default)
}
pub(crate) fn assert_semantic_predicate_in_scope(
&mut self,
from: NodeKey,
to: NodeKey,
predicate: String,
graph_scope: GraphScope,
) -> Option<EdgeKey> {
if !self.inner.contains_node(from) || !self.inner.contains_node(to) {
return None;
}
let edge_key = self
.find_edge_key(from, to)
.unwrap_or_else(|| self.inner.connect(from, to, EdgePayload::new()));
let changed = {
let payload = self.inner.edge_mut(edge_key)?;
payload.assert_semantic_predicate_in_scope(predicate, graph_scope)
};
if changed {
self.bump_revision();
return Some(edge_key);
}
None
}
pub(crate) fn replay_add_node_with_id_if_missing(
&mut self,
id: Uuid,
url: String,
position: Point2D<f32>,
) -> Option<NodeKey> {
if self.get_node_key_by_id(id).is_some() {
return None;
}
Some(self.add_node_with_id(id, url, position))
}
pub(crate) fn replay_remove_node_by_id(&mut self, node_id: Uuid) -> bool {
let Some(key) = self.get_node_key_by_id(node_id) else {
return false;
};
self.remove_node(key)
}
pub(crate) fn replay_retract_relations_by_ids(
&mut self,
from_id: Uuid,
to_id: Uuid,
selector: RelationSelector,
) -> usize {
let Some(from_key) = self.get_node_key_by_id(from_id) else {
return 0;
};
let Some(to_key) = self.get_node_key_by_id(to_id) else {
return 0;
};
self.retract_relations(from_key, to_key, selector)
}
pub(crate) fn replay_assert_relation_by_ids(
&mut self,
from_id: Uuid,
to_id: Uuid,
assertion: EdgeAssertion,
) -> Option<EdgeKey> {
let from_key = self.get_node_key_by_id(from_id)?;
let to_key = self.get_node_key_by_id(to_id)?;
self.assert_relation(from_key, to_key, assertion)
}
pub(crate) fn replay_set_edge_semantic_predicate_by_ids(
&mut self,
from_id: Uuid,
to_id: Uuid,
predicate: Option<String>,
) -> bool {
let Some(from_key) = self.get_node_key_by_id(from_id) else {
return false;
};
let Some(to_key) = self.get_node_key_by_id(to_id) else {
return false;
};
let Some(edge_key) = self.find_edge_key(from_key, to_key) else {
return false;
};
self.set_edge_semantic_predicate(edge_key, predicate)
}
pub(crate) fn replay_assert_semantic_predicate_by_ids(
&mut self,
from_id: Uuid,
to_id: Uuid,
predicate: String,
) -> Option<EdgeKey> {
let from_key = self.get_node_key_by_id(from_id)?;
let to_key = self.get_node_key_by_id(to_id)?;
self.assert_semantic_predicate(from_key, to_key, predicate)
}
pub(crate) fn replay_append_traversal_by_ids(
&mut self,
from_id: Uuid,
to_id: Uuid,
trigger: super::edge_taxonomy::NavigationTrigger,
timestamp_ms: u64,
) -> bool {
let Some(from_key) = self.get_node_key_by_id(from_id) else {
return false;
};
let Some(to_key) = self.get_node_key_by_id(to_id) else {
return false;
};
self.append_traversal(from_key, to_key, trigger, Some(timestamp_ms))
}
pub(crate) fn dissolve_remove_node_collect_traversals(
&mut self,
key: NodeKey,
) -> Option<Vec<DissolvedTraversalRecord>> {
let _ = self.get_node(key)?;
let mut records = Vec::new();
let inner = self.inner.inner();
for edge in inner
.edges_directed(key, Direction::Outgoing)
.chain(inner.edges_directed(key, Direction::Incoming))
{
if edge.weight().traversals().is_empty() {
continue;
}
let from_node = self.get_node(edge.source())?;
let to_node = self.get_node(edge.target())?;
records.push(DissolvedTraversalRecord {
from_node_id: from_node.id,
to_node_id: to_node.id,
traversals: edge.weight().traversals().to_vec(),
});
}
let _ = self.remove_node(key);
Some(records)
}
pub fn collect_node_traversals(&self, key: NodeKey) -> Option<Vec<DissolvedTraversalRecord>> {
let _ = self.get_node(key)?;
let mut records = Vec::new();
let inner = self.inner.inner();
for edge in inner
.edges_directed(key, Direction::Outgoing)
.chain(inner.edges_directed(key, Direction::Incoming))
{
if edge.weight().traversals().is_empty() {
continue;
}
let from_node = self.get_node(edge.source())?;
let to_node = self.get_node(edge.target())?;
records.push(DissolvedTraversalRecord {
from_node_id: from_node.id,
to_node_id: to_node.id,
traversals: edge.weight().traversals().to_vec(),
});
}
Some(records)
}
pub fn assert_semantic_statement(
&mut self,
from: NodeKey,
to: NodeKey,
spec: SemanticStatementSpec,
) -> Option<(EdgeKey, StatementAssert)> {
if !self.inner.contains_node(from) || !self.inner.contains_node(to) {
return None;
}
let edge_key = self
.find_edge_key(from, to)
.unwrap_or_else(|| self.inner.connect(from, to, EdgePayload::new()));
let outcome = {
let payload = self.inner.edge_mut(edge_key)?;
payload.assert_semantic_statement(spec)
};
if outcome.changed {
self.bump_revision();
}
Some((edge_key, outcome))
}
pub fn assert_persisted_semantic_statement(
&mut self,
from: NodeKey,
to: NodeKey,
statement: SemanticStatement,
) -> Option<EdgeKey> {
if !self.inner.contains_node(from) || !self.inner.contains_node(to) {
return None;
}
let edge_key = self
.find_edge_key(from, to)
.unwrap_or_else(|| self.inner.connect(from, to, EdgePayload::new()));
let changed = {
let payload = self.inner.edge_mut(edge_key)?;
payload.push_persisted_semantic_statement(statement)
};
if changed {
self.bump_revision();
}
Some(edge_key)
}
pub fn retract_semantic_statement(
&mut self,
from: NodeKey,
to: NodeKey,
statement_id: &str,
) -> bool {
let Some(edge_key) = self.find_edge_key(from, to) else {
return false;
};
let (removed, now_empty) = {
let Some(payload) = self.inner.edge_mut(edge_key) else {
return false;
};
let removed = payload.retract_semantic_statement(statement_id);
(removed, removed && payload.is_empty())
};
if now_empty {
let _ = self.inner.disconnect(edge_key);
}
if removed {
self.bump_revision();
}
removed
}
pub(crate) fn retract_relations(
&mut self,
from: NodeKey,
to: NodeKey,
selector: RelationSelector,
) -> usize {
let edge_ids: Vec<EdgeKey> = self
.inner
.inner()
.edge_references()
.filter(|edge| {
edge.source() == from && edge.target() == to && edge.weight().has_relation(selector)
})
.map(|edge| edge.id())
.collect();
let mut removed = 0usize;
let mut edges_to_delete = Vec::new();
for edge_id in edge_ids {
if let Some(payload) = self.inner.edge_mut(edge_id)
&& payload.retract_relation(selector)
{
removed += 1;
if payload.is_empty() {
edges_to_delete.push(edge_id);
}
}
}
for edge_id in edges_to_delete {
let _ = self.inner.disconnect(edge_id);
}
if removed > 0 {
self.bump_revision();
}
removed
}
pub(crate) fn get_edge_mut(&mut self, key: EdgeKey) -> Option<&mut EdgePayload> {
self.inner.edge_mut(key)
}
pub(crate) fn set_edge_semantic_predicate(
&mut self,
key: EdgeKey,
predicate: Option<String>,
) -> bool {
let Some(payload) = self.inner.edge_mut(key) else {
return false;
};
payload.set_semantic_predicate(predicate);
true
}
pub fn get_edge(&self, key: EdgeKey) -> Option<&EdgePayload> {
self.inner.edge(key)
}
pub fn find_edge_key(&self, from: NodeKey, to: NodeKey) -> Option<EdgeKey> {
self.inner.inner().find_edge(from, to)
}
pub(crate) fn push_traversal(
&mut self,
from: NodeKey,
to: NodeKey,
traversal: Traversal,
) -> bool {
if from == to || !self.inner.contains_node(from) || !self.inner.contains_node(to) {
return false;
}
if let Some(edge_key) = self.find_edge_key(from, to)
&& let Some(payload) = self.inner.edge_mut(edge_key)
{
payload.push_traversal(traversal);
return true;
}
let mut payload = EdgePayload::new();
payload.push_traversal(traversal);
let _ = self.inner.connect(from, to, payload);
self.bump_revision();
true
}
pub(crate) fn append_traversal(
&mut self,
from: NodeKey,
to: NodeKey,
trigger: super::edge_taxonomy::NavigationTrigger,
timestamp_ms: Option<u64>,
) -> bool {
let traversal = match timestamp_ms {
Some(timestamp_ms) => Traversal {
timestamp_ms,
trigger,
},
None => Traversal::now(trigger),
};
self.push_traversal(from, to, traversal)
}
}