reactive_graph_table_model/types/
flows.rs

1use crate::container::TableInlineFormat;
2use crate::container::TableInlineFormatSetter;
3use crate::container::TableOptions;
4use crate::instances::entities::EntityInstance;
5use crate::instances::entities::display_entity_instances_html_inline;
6use crate::instances::entities::display_entity_instances_inline_str;
7use crate::instances::relations::RelationInstance;
8use crate::instances::relations::display_relation_instances_html_inline;
9use crate::instances::relations::display_relation_instances_inline_str;
10use crate::types::extension::Extension;
11use crate::types::extension::Extensions;
12use crate::types::extension::display_extensions_html_inline;
13use crate::types::extension::display_extensions_inline_str;
14use crate::types::properties::display_property_types_html_inline;
15use crate::types::properties::display_property_types_inline_str;
16use crate::types::variables::Variables;
17use reactive_graph_graph::NamespacedTypeGetter;
18use tabled::Table;
19use tabled::Tabled;
20use tabled::settings::Modify;
21use tabled::settings::Style;
22use tabled::settings::Width;
23use tabled::settings::object::Segment;
24
25#[derive(Clone, Debug, Tabled)]
26pub struct FlowType {
27    /// The namespace of the flow type.
28    pub namespace: String,
29
30    /// The name of the extension.
31    pub name: String,
32
33    /// Textual description of the extension.
34    pub description: String,
35
36    /// The wrapper entity instance.
37    #[tabled(skip)]
38    pub wrapper_entity_instance: EntityInstance,
39
40    /// The entity instances.
41    // [tabled(display("Self::display_entity_instances", self))]
42    #[tabled(skip)]
43    pub entity_instances: Vec<EntityInstance>,
44
45    /// The relation instances.
46    // [tabled(display("Self::display_relation_instances", self))]
47    #[tabled(skip)]
48    pub relation_instances: Vec<RelationInstance>,
49
50    // pub wrapper_entity_instance: EntityInstance,
51    /// The variables.
52    #[tabled(display("display_variables", self))]
53    pub variables: Variables,
54
55    /// The extensions.
56    #[tabled(display("display_extensions", self))]
57    pub extensions: Vec<Extension>,
58
59    #[tabled(skip)]
60    inline_format: TableInlineFormat,
61}
62
63#[allow(unused)]
64fn display_entity_instances(entity_instances: &[EntityInstance], flow_type: &FlowType) -> String {
65    match flow_type.inline_format {
66        TableInlineFormat::Table => display_entity_instances_inline_str(entity_instances),
67        TableInlineFormat::Html => display_entity_instances_html_inline(entity_instances),
68    }
69}
70
71#[allow(unused)]
72fn display_relation_instances(relation_instances: &[RelationInstance], flow_type: &FlowType) -> String {
73    match flow_type.inline_format {
74        TableInlineFormat::Table => display_relation_instances_inline_str(relation_instances),
75        TableInlineFormat::Html => display_relation_instances_html_inline(relation_instances),
76    }
77}
78
79fn display_variables(variables: &Variables, flow_type: &FlowType) -> String {
80    match flow_type.inline_format {
81        TableInlineFormat::Table => display_property_types_inline_str(&variables.0),
82        TableInlineFormat::Html => display_property_types_html_inline(&variables.0),
83    }
84}
85
86fn display_extensions(extensions: &[Extension], flow_type: &FlowType) -> String {
87    match flow_type.inline_format {
88        TableInlineFormat::Table => display_extensions_inline_str(extensions),
89        TableInlineFormat::Html => display_extensions_html_inline(extensions),
90    }
91}
92
93impl TableInlineFormatSetter for FlowType {
94    fn set_table_inline_format(&mut self, table_inline_format: TableInlineFormat) {
95        self.inline_format = table_inline_format;
96    }
97}
98
99impl From<reactive_graph_graph::FlowType> for FlowType {
100    fn from(flow_type: reactive_graph_graph::FlowType) -> Self {
101        // let x = flow_type.wrapper_entity_instance;
102        let namespace = flow_type.namespace();
103        let name = flow_type.type_name();
104        let variables = Variables::from(flow_type.variables.clone());
105        let entity_instances = flow_type
106            .entity_instances
107            .into_iter()
108            .map(|(_, entity_instance)| entity_instance.into())
109            .collect();
110        let relation_instances = flow_type
111            .relation_instances
112            .into_iter()
113            .map(|(_, relation_instance)| relation_instance.into())
114            .collect();
115        FlowType {
116            namespace,
117            name,
118            description: flow_type.description,
119            wrapper_entity_instance: flow_type.wrapper_entity_instance.into(),
120            entity_instances,
121            relation_instances,
122            variables,
123            extensions: Extensions::from(flow_type.extensions).0,
124            inline_format: Default::default(),
125        }
126    }
127}
128
129pub struct FlowTypesTableOptions;
130
131impl TableOptions for FlowTypesTableOptions {
132    fn options(table: &mut Table) -> &mut Table {
133        table.with(Style::extended()).with(
134            Modify::new(Segment::new(0.., 0..3))
135                .with(Width::increase(22))
136                .with(Width::increase(22))
137                .with(Width::wrap(40).keep_words(true)),
138        )
139    }
140}