1 files changed, 112 insertions, 30 deletions

diff --git a/src/entities.rs b/src/entities.rs
index b7368df..89905c6 100644
--- a/src/entities.rs
+++ b/src/entities.rs
@@ -1,16 +1,17 @@
 use std::collections::HashMap;
 
+pub(crate) type DynEntity = dyn Entity + Sync + Send;
+
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub(crate) struct Usr(pub(crate) String);
 
-#[derive(Debug, Clone)]
 pub(crate) struct EntitiesManager {
-    toplevel_entities: HashMap<Usr, Entity>,
+    toplevel_entities: HashMap<Usr, Box<DynEntity>>,
     descriptions: HashMap<Usr, Description>,
 }
 
 pub(crate) struct EntitiesManagerComponents {
-    pub(crate) toplevel_entities: HashMap<Usr, Entity>,
+    pub(crate) toplevel_entities: HashMap<Usr, Box<DynEntity>>,
     pub(crate) descriptions: HashMap<Usr, Description>,
 }
 
@@ -27,7 +28,7 @@ impl EntitiesManager {
         self.descriptions.insert(usr, description);
     }
 
-    pub fn insert_toplevel(&mut self, usr: Usr, entity: Entity) {
+    pub fn insert_toplevel(&mut self, usr: Usr, entity: Box<DynEntity>) {
         self.toplevel_entities.insert(usr, entity);
     }
 
@@ -61,33 +62,88 @@ pub(crate) struct Described<T> {
     pub(crate) entity: T,
 }
 
+pub(crate) struct ChildGroup<'a> {
+    pub(crate) name: &'static str,
+    pub(crate) children: Vec<(&'a Usr, &'a DynEntity)>,
+}
+
+pub(crate) trait Entity {
+    fn kind_name(&self) -> &'static str;
+    fn embeddable_children(&self) -> Vec<ChildGroup> {
+        Vec::new()
+    }
+    fn separate_children(&self) -> Vec<ChildGroup> {
+        Vec::new()
+    }
+}
+
 #[derive(Debug, Clone)]
-pub(crate) enum Entity {
+pub(crate) struct NameSpace {
+    // TODO: replace with Vec to keep order
+    pub(crate) members: HashMap<Usr, NameSpaceChild>,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) enum NameSpaceChild {
     NameSpace(NameSpace),
+    Class(Class),
     Variable(Variable),
     Function(Function),
-    Class(Class),
 }
 
-impl Entity {
+impl Entity for NameSpace {
     fn kind_name(&self) -> &'static str {
-        match self {
-            Entity::NameSpace(_) => "namespace",
-            Entity::Variable(_) => "variable",
-            Entity::Function(_) => "function",
-            Entity::Class(_) => "class",
+        "namespace"
+    }
+
+    fn embeddable_children(&self) -> Vec<ChildGroup> {
+        let mut variables = Vec::new();
+        let mut functions = Vec::new();
+        for (usr, member) in &self.members {
+            match member {
+                NameSpaceChild::NameSpace(_) => {}
+                NameSpaceChild::Class(_) => {}
+                NameSpaceChild::Variable(variable) => variables.push((usr, variable as &DynEntity)),
+                NameSpaceChild::Function(function) => functions.push((usr, function as &DynEntity)),
+            }
         }
+
+        vec![
+            ChildGroup {
+                name: "Variables",
+                children: variables,
+            },
+            ChildGroup {
+                name: "Functions",
+                children: functions,
+            },
+        ]
     }
-}
 
-#[derive(Debug, Clone)]
-pub(crate) struct NameSpace {
-    pub(crate) members: HashMap<Usr, Entity>,
-}
+    fn separate_children(&self) -> Vec<ChildGroup> {
+        let mut namespaces = Vec::new();
+        let mut classes = Vec::new();
+        for (usr, member) in &self.members {
+            match member {
+                NameSpaceChild::NameSpace(namespace) => {
+                    namespaces.push((usr, namespace as &DynEntity))
+                }
+                NameSpaceChild::Class(class) => classes.push((usr, class as &DynEntity)),
+                NameSpaceChild::Variable(_) => {}
+                NameSpaceChild::Function(_) => {}
+            }
+        }
 
-impl From<NameSpace> for Entity {
-    fn from(ns: NameSpace) -> Self {
-        Entity::NameSpace(ns)
+        vec![
+            ChildGroup {
+                name: "Namespaces",
+                children: namespaces,
+            },
+            ChildGroup {
+                name: "Classes",
+                children: classes,
+            },
+        ]
     }
 }
 
@@ -96,9 +152,9 @@ pub(crate) struct Variable {
     pub(crate) r#type: String,
 }
 
-impl From<Variable> for Entity {
-    fn from(var: Variable) -> Self {
-        Entity::Variable(var)
+impl Entity for Variable {
+    fn kind_name(&self) -> &'static str {
+        "variable"
     }
 }
 
@@ -108,9 +164,9 @@ pub(crate) struct Function {
     pub(crate) return_type: String,
 }
 
-impl From<Function> for Entity {
-    fn from(func: Function) -> Self {
-        Entity::Function(func)
+impl Entity for Function {
+    fn kind_name(&self) -> &'static str {
+        "function"
     }
 }
 
@@ -122,13 +178,39 @@ pub(crate) struct FunctionArgument {
 
 #[derive(Debug, Clone)]
 pub(crate) struct Class {
-    pub(crate) member_types: Vec<Usr>,
+    //pub(crate) member_types: Vec<Usr>,
+    // TODO: replace with Vec to keep order
     pub(crate) member_functions: HashMap<Usr, Function>,
     pub(crate) member_variables: HashMap<Usr, Variable>,
 }
 
-impl From<Class> for Entity {
-    fn from(class: Class) -> Self {
-        Entity::Class(class)
+impl Entity for Class {
+    fn kind_name(&self) -> &'static str {
+        "class"
+    }
+
+    fn embeddable_children(&self) -> Vec<ChildGroup> {
+        vec![
+            ChildGroup {
+                name: "Functions",
+                children: self
+                    .member_functions
+                    .iter()
+                    .map(|(usr, func)| (usr, func as &DynEntity))
+                    .collect(),
+            },
+            ChildGroup {
+                name: "Variables",
+                children: self
+                    .member_variables
+                    .iter()
+                    .map(|(usr, var)| (usr, var as &DynEntity))
+                    .collect(),
+            },
+        ]
+    }
+
+    fn separate_children(&self) -> Vec<ChildGroup> {
+        Vec::new()
     }
 }