use super::{Graph, ResourceNode};
use serde::{Deserialize, Serialize};
use uuid::Uuid;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CoverageLayer {
Possession,
Residency,
Disclosure,
Synchronization,
Projection,
}
impl CoverageLayer {
pub const ALL: [Self; 5] = [
Self::Possession,
Self::Residency,
Self::Disclosure,
Self::Synchronization,
Self::Projection,
];
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CoverageLimit {
pub layer: CoverageLayer,
pub reason: String,
#[serde(default)]
pub resources: Vec<Uuid>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub surfaces: Vec<Uuid>,
#[serde(default)]
pub count: Option<usize>,
}
impl CoverageLimit {
pub fn new(layer: CoverageLayer, reason: impl Into<String>) -> Self {
Self {
layer,
reason: reason.into(),
resources: vec![],
surfaces: vec![],
count: None,
}
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct CoverageNote {
pub limits: Vec<CoverageLimit>,
}
impl CoverageNote {
pub fn push(&mut self, limit: CoverageLimit) {
if !self.limits.contains(&limit) {
self.limits.push(limit);
}
}
pub fn add_count(&mut self, layer: CoverageLayer, reason: impl Into<String>, count: usize) {
if count == 0 {
return;
}
let mut limit = CoverageLimit::new(layer, reason);
limit.count = Some(count);
self.push(limit);
}
}
impl Graph {
pub fn known_coverage(&self) -> &CoverageNote {
&self.known_coverage
}
pub fn set_known_coverage(&mut self, note: CoverageNote) {
if self.known_coverage != note {
self.known_coverage = note;
self.semantic_observation_revision += 1;
}
}
pub fn coverage_note(&self) -> CoverageNote {
let mut note = self.known_coverage.clone();
let mut unavailable = 0;
let mut unasserted = 0;
for link in self.pending_links() {
let missing: Vec<_> = [
link.source_resource,
ResourceNode::new(&link.target_iri).id(),
]
.into_iter()
.filter(|id| self.resource(*id).is_none())
.collect();
if missing.is_empty() {
unasserted += 1;
continue;
}
if missing.iter().any(|id| {
!self.known_coverage.limits.iter().any(|limit| {
limit.layer == CoverageLayer::Residency
&& ((limit.resources.is_empty() && limit.surfaces.is_empty())
|| limit.resources.contains(id))
})
}) {
unavailable += 1;
}
}
note.add_count(
CoverageLayer::Possession,
"pending source claims have unavailable endpoints",
unavailable,
);
note.add_count(
CoverageLayer::Possession,
"pending source claims await assertion placement",
unasserted,
);
note
}
pub fn coverage_for_resource_refs(&self, references: &[Uuid]) -> CoverageNote {
let mut note = self.coverage_note();
let missing: std::collections::BTreeSet<_> = references
.iter()
.copied()
.filter(|id| self.resource(*id).is_none())
.filter(|id| {
!self.known_coverage.limits.iter().any(|limit| {
limit.layer == CoverageLayer::Residency
&& ((limit.resources.is_empty() && limit.surfaces.is_empty())
|| limit.resources.contains(id))
})
})
.collect();
if !missing.is_empty() {
let mut limit = CoverageLimit::new(
CoverageLayer::Possession,
"referenced resources are unavailable",
);
limit.count = Some(missing.len());
limit.resources = missing.into_iter().collect();
note.push(limit);
}
note
}
pub fn copy_semantic_context_from(&mut self, graph: &Self) {
self.restore_pending_link_state(graph.pending_link_state.clone());
self.set_known_coverage(graph.known_coverage.clone());
}
pub fn clear_semantic_context(&mut self) {
self.restore_pending_link_state(Default::default());
self.set_known_coverage(Default::default());
}
}
#[cfg(test)]
mod residency_scope_tests {
use super::*;
#[test]
fn surface_scope_does_not_hide_absent_resources() {
let mut graph = Graph::new();
let mut limit = CoverageLimit::new(CoverageLayer::Residency, "surface unloaded");
limit.surfaces.push(Uuid::from_u128(1));
graph.set_known_coverage(CoverageNote {
limits: vec![limit.clone()],
});
let unknown = Uuid::from_u128(2);
assert!(
graph
.coverage_for_resource_refs(&[unknown])
.limits
.iter()
.any(|l| l.layer == CoverageLayer::Possession)
);
limit.resources.push(unknown);
graph.set_known_coverage(CoverageNote {
limits: vec![limit.clone()],
});
assert!(
!graph
.coverage_for_resource_refs(&[unknown])
.limits
.iter()
.any(|l| l.layer == CoverageLayer::Possession)
);
limit.surfaces.clear();
limit.resources.clear();
assert!(
serde_json::to_value(&limit)
.unwrap()
.get("surfaces")
.is_none()
);
graph.set_known_coverage(CoverageNote {
limits: vec![limit],
});
assert!(
!graph
.coverage_for_resource_refs(&[unknown])
.limits
.iter()
.any(|l| l.layer == CoverageLayer::Possession)
);
}
}