reactive_graph_plugin_delegates/
relation_instance_manager_impl.rs1use std::sync::Arc;
2
3use serde_json::Value;
4use uuid::Uuid;
5
6use reactive_graph_behaviour_model_api::BehaviourTypeId;
7use reactive_graph_graph::ComponentTypeId;
8use reactive_graph_graph::Mutability;
9use reactive_graph_graph::Namespace;
10use reactive_graph_graph::RelationInstance;
11use reactive_graph_graph::RelationInstanceId;
12use reactive_graph_graph::RelationTypeId;
13use reactive_graph_reactive_model_impl::ReactiveRelation;
14use reactive_graph_reactive_service_api::ReactiveRelationComponentAddError;
15use reactive_graph_reactive_service_api::ReactiveRelationComponentRemoveError;
16use reactive_graph_reactive_service_api::ReactiveRelationCreationError;
17use reactive_graph_reactive_service_api::ReactiveRelationManager;
18use reactive_graph_reactive_service_api::ReactiveRelationPropertyAddError;
19use reactive_graph_reactive_service_api::ReactiveRelationPropertyRemoveError;
20use reactive_graph_reactive_service_api::ReactiveRelationRegistrationError;
21use reactive_graph_type_system_api::ComponentManager;
22use reactive_graph_type_system_api::RelationTypeManager;
23
24pub struct RelationInstanceManagerDelegate {
25 component_manager: Arc<dyn ComponentManager + Send + Sync>,
26 relation_type_manager: Arc<dyn RelationTypeManager + Send + Sync>,
27 reactive_relation_manager: Arc<dyn ReactiveRelationManager + Send + Sync>,
28}
29
30impl RelationInstanceManagerDelegate {
31 pub fn new(
32 component_manager: Arc<dyn ComponentManager + Send + Sync>,
33 relation_type_manager: Arc<dyn RelationTypeManager + Send + Sync>,
34 reactive_relation_manager: Arc<dyn ReactiveRelationManager + Send + Sync>,
35 ) -> Self {
36 Self {
37 component_manager,
38 relation_type_manager,
39 reactive_relation_manager,
40 }
41 }
42}
43impl reactive_graph_plugin_api::RelationInstanceManager for RelationInstanceManagerDelegate {
44 fn has(&self, relation_instance_id: &RelationInstanceId) -> bool {
45 self.reactive_relation_manager.has(relation_instance_id)
46 }
47
48 fn get(&self, relation_instance_id: &RelationInstanceId) -> Option<ReactiveRelation> {
49 self.reactive_relation_manager.get(relation_instance_id)
50 }
51
52 fn get_by_outbound_entity(&self, outbound_entity_id: Uuid) -> Vec<ReactiveRelation> {
53 self.reactive_relation_manager.get_by_outbound_entity(outbound_entity_id)
54 }
55
56 fn get_by_inbound_entity(&self, inbound_entity_id: Uuid) -> Vec<ReactiveRelation> {
57 self.reactive_relation_manager.get_by_inbound_entity(inbound_entity_id)
58 }
59
60 fn get_all(&self) -> Vec<ReactiveRelation> {
61 self.reactive_relation_manager.get_all()
62 }
63
64 fn get_by_type(&self, ty: &RelationTypeId) -> Vec<ReactiveRelation> {
65 self.reactive_relation_manager.get_by_type(ty)
66 }
67
68 fn get_by_namespace(&self, namespace: &Namespace) -> Vec<ReactiveRelation> {
69 self.reactive_relation_manager.get_by_namespace(namespace)
70 }
71
72 fn get_keys(&self) -> Vec<RelationInstanceId> {
73 self.reactive_relation_manager.get_relation_instance_ids()
74 }
75
76 fn count(&self) -> usize {
77 self.reactive_relation_manager.count()
78 }
79
80 fn count_by_type(&self, ty: &RelationTypeId) -> usize {
81 self.reactive_relation_manager.count_by_type(ty)
82 }
83
84 fn count_by_component(&self, component: &ComponentTypeId) -> usize {
85 self.reactive_relation_manager.count_by_component(component)
86 }
87
88 fn count_by_behaviour(&self, behaviour_ty: &BehaviourTypeId) -> usize {
89 self.reactive_relation_manager.count_by_behaviour(behaviour_ty)
90 }
91
92 fn create(&self, relation_instance: RelationInstance) -> Result<ReactiveRelation, ReactiveRelationCreationError> {
93 let relation_ty = relation_instance.relation_type_id();
94 let relation_type = self.relation_type_manager.get(&relation_ty);
95 match relation_type {
97 Some(relation_type) => {
98 let id = relation_instance.id();
99 if self.reactive_relation_manager.has(&id) {
100 if let Some(reactive_relation_instance) = self.reactive_relation_manager.get(&id) {
101 return Ok(reactive_relation_instance);
102 }
103 }
104 let relation_instance = relation_instance;
105 for property in relation_type.properties.iter() {
107 if !relation_instance.properties.contains_key(property.key()) {
108 relation_instance.properties.insert(property.key().clone(), property.data_type.default_value());
109 }
110 }
111 for component_ty in relation_type.components.iter() {
113 if let Some(component) = self.component_manager.get(&component_ty) {
114 for property in component.properties.iter() {
115 if !relation_instance.properties.contains_key(property.key()) {
116 relation_instance.properties.insert(property.key().clone(), property.data_type.default_value());
117 }
118 }
119 }
120 }
121 self.reactive_relation_manager.create_reactive_instance(relation_instance)
122 }
123 None => Err(ReactiveRelationCreationError::UnknownRelationType(relation_ty.clone())),
124 }
125 }
126
127 fn register(&self, reactive_relation: ReactiveRelation) -> Result<ReactiveRelation, ReactiveRelationRegistrationError> {
128 self.reactive_relation_manager.register_reactive_instance(reactive_relation)
129 }
130
131 fn add_component(&self, relation_instance_id: &RelationInstanceId, component: &ComponentTypeId) -> Result<(), ReactiveRelationComponentAddError> {
132 self.reactive_relation_manager.add_component(relation_instance_id, component)
133 }
134
135 fn remove_component(&self, relation_instance_id: &RelationInstanceId, component: &ComponentTypeId) -> Result<(), ReactiveRelationComponentRemoveError> {
136 self.reactive_relation_manager.remove_component(relation_instance_id, component)
137 }
138
139 fn add_property(
140 &self,
141 relation_instance_id: &RelationInstanceId,
142 property_name: &str,
143 mutability: Mutability,
144 value: Value,
145 ) -> Result<(), ReactiveRelationPropertyAddError> {
146 self.reactive_relation_manager
147 .add_property(relation_instance_id, property_name, mutability, value)
148 }
149
150 fn remove_property(&self, relation_instance_id: &RelationInstanceId, property_name: &str) -> Result<(), ReactiveRelationPropertyRemoveError> {
151 self.reactive_relation_manager.remove_property(relation_instance_id, property_name)
152 }
153
154 fn delete(&self, id: &RelationInstanceId) -> bool {
155 self.reactive_relation_manager.delete(id)
156 }
157}