reactive_graph_graph/types/properties/
divergent.rs

1use crate::ComponentTypeId;
2use crate::ComponentTypeIds;
3use crate::PropertyType;
4use std::collections::HashMap;
5use std::ops::Deref;
6
7pub struct DivergentPropertyType {
8    existing: PropertyType,
9    divergent: PropertyType,
10}
11
12impl DivergentPropertyType {
13    pub fn new(existing: &PropertyType, divergent: &PropertyType) -> Self {
14        Self {
15            existing: existing.clone(),
16            divergent: divergent.clone(),
17        }
18    }
19
20    pub fn existing(&self) -> &PropertyType {
21        &self.existing
22    }
23
24    pub fn divergent(&self) -> &PropertyType {
25        &self.divergent
26    }
27}
28
29pub struct DivergentPropertyTypes(Vec<DivergentPropertyType>);
30
31impl DivergentPropertyTypes {
32    pub fn new() -> Self {
33        Self(Vec::new())
34    }
35
36    pub fn push(&mut self, existing: &PropertyType, divergent: &PropertyType) {
37        self.0.push(DivergentPropertyType::new(existing, divergent));
38    }
39
40    pub fn is_empty(&self) -> bool {
41        self.0.is_empty()
42    }
43}
44
45impl Deref for DivergentPropertyTypes {
46    type Target = Vec<DivergentPropertyType>;
47
48    fn deref(&self) -> &Self::Target {
49        &self.0
50    }
51}
52
53pub struct Divergent {
54    divergent_components: HashMap<ComponentTypeId, DivergentPropertyTypes>,
55    unfulfilled_components: ComponentTypeIds,
56}
57
58impl Divergent {
59    pub fn new() -> Self {
60        Divergent {
61            divergent_components: HashMap::new(),
62            unfulfilled_components: ComponentTypeIds::new(),
63        }
64    }
65
66    pub fn is_divergent(&self) -> bool {
67        !self.divergent_components.is_empty() || !self.unfulfilled_components.is_empty()
68    }
69
70    pub fn divergent_component<TY: Into<ComponentTypeId>>(&mut self, ty: TY, divergent_property_types: DivergentPropertyTypes) {
71        self.divergent_components.insert(ty.into(), divergent_property_types);
72    }
73    pub fn unfulfilled_component<TY: Into<ComponentTypeId>>(&mut self, ty: TY) {
74        self.unfulfilled_components.insert(ty.into());
75    }
76
77    pub fn divergent_components(&self) -> ComponentTypeIds {
78        let divergent_components = self.unfulfilled_components.clone();
79        for ty in self.divergent_components.keys().cloned() {
80            divergent_components.insert(ty);
81        }
82        divergent_components
83    }
84}