1 files changed, 390 insertions, 0 deletions

diff --git a/src/parser/clang/entities.rs b/src/parser/clang/entities.rs
new file mode 100644
index 0000000..41fe061
--- /dev/null
+++ b/src/parser/clang/entities.rs
@@ -0,0 +1,390 @@
+use crate::types::*;
+
+use clang::{EntityKind, Usr};
+use thiserror::Error;
+
+use std::collections::BTreeMap;
+use std::convert::TryFrom;
+
+// TODO: factor out hardcoded strings
+
+#[derive(Debug)]
+pub(super) struct Children {
+    namespaces: Option<BTreeMap<Usr, Described<Namespace>>>,
+    variables: Option<BTreeMap<Usr, Described<Variable>>>,
+    structs: Option<BTreeMap<Usr, Described<Struct>>>,
+    functions: Option<BTreeMap<Usr, Described<Function>>>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(super) enum ClangEntityKind {
+    Namespace,
+    Variable(VariableKind),
+    Struct(StructKind),
+    Function(FunctionKind),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(super) enum VariableKind {
+    Variable,
+    Field,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(super) enum StructKind {
+    Struct,
+    Class,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(super) enum FunctionKind {
+    Function,
+    Method,
+}
+
+impl ClangEntityKind {
+    fn to_str_singular(self) -> &'static str {
+        match self {
+            ClangEntityKind::Namespace => "namespace",
+            ClangEntityKind::Variable(VariableKind::Variable) => "variable",
+            ClangEntityKind::Variable(VariableKind::Field) => "field",
+            ClangEntityKind::Struct(StructKind::Struct) => "struct",
+            ClangEntityKind::Struct(StructKind::Class) => "class",
+            ClangEntityKind::Function(FunctionKind::Function) => "function",
+            ClangEntityKind::Function(FunctionKind::Method) => "method",
+        }
+    }
+
+    fn to_str_plural(self) -> &'static str {
+        match self {
+            ClangEntityKind::Namespace => "namespaces",
+            ClangEntityKind::Variable(VariableKind::Variable) => "variables",
+            ClangEntityKind::Variable(VariableKind::Field) => "fields",
+            ClangEntityKind::Struct(StructKind::Struct) => "structs",
+            ClangEntityKind::Struct(StructKind::Class) => "classes",
+            ClangEntityKind::Function(FunctionKind::Function) => "functions",
+            ClangEntityKind::Function(FunctionKind::Method) => "methods",
+        }
+    }
+}
+
+#[derive(Debug, Error)]
+#[error("Unsupported Clang entity kind: {:?}", _0)]
+pub(super) struct TryFromEntityKindError(String);
+
+impl TryFrom<EntityKind> for ClangEntityKind {
+    type Error = TryFromEntityKindError;
+
+    fn try_from(kind: EntityKind) -> Result<ClangEntityKind, TryFromEntityKindError> {
+        Ok(match kind {
+            EntityKind::Namespace => ClangEntityKind::Namespace,
+            EntityKind::VarDecl => ClangEntityKind::Variable(VariableKind::Variable),
+            EntityKind::FieldDecl => ClangEntityKind::Variable(VariableKind::Field),
+            EntityKind::FunctionDecl => ClangEntityKind::Function(FunctionKind::Function),
+            EntityKind::Method | EntityKind::Constructor => {
+                ClangEntityKind::Function(FunctionKind::Method)
+            }
+            EntityKind::StructDecl => ClangEntityKind::Struct(StructKind::Struct),
+            EntityKind::ClassDecl => ClangEntityKind::Struct(StructKind::Class),
+            kind => return Err(TryFromEntityKindError(format!("{:?}", kind))),
+        })
+    }
+}
+
+pub(super) trait ClangEntity {
+    fn kind(&self) -> ClangEntityKind;
+
+    fn get_member_namespaces(&mut self) -> Option<&mut BTreeMap<Usr, Described<Namespace>>> {
+        None
+    }
+    fn get_member_variables(&mut self) -> Option<&mut BTreeMap<Usr, Described<Variable>>> {
+        None
+    }
+    fn get_member_structs(&mut self) -> Option<&mut BTreeMap<Usr, Described<Struct>>> {
+        None
+    }
+    fn get_member_functions(&mut self) -> Option<&mut BTreeMap<Usr, Described<Function>>> {
+        None
+    }
+
+    fn into_children(self) -> Children
+    where
+        Self: Sized,
+    {
+        Children {
+            namespaces: None,
+            variables: None,
+            structs: None,
+            functions: None,
+        }
+    }
+}
+
+/*
+pub(super) trait FromNamespaceParent: ClangEntity + Sized {
+    fn from_namespace_parent<'a>(
+        parent: &'a mut Described<Namespace>,
+        name: &Usr,
+    ) -> Option<&'a mut Described<Self>>;
+}
+*/
+
+pub(super) trait NamespaceParentManipulation<T: ClangEntity + Sized> {
+    fn get_members_mut(&mut self) -> Option<&mut BTreeMap<Usr, Described<T>>>;
+}
+
+impl<U> NamespaceParentManipulation<Namespace> for U
+where
+    U: ClangEntity,
+{
+    fn get_members_mut(&mut self) -> Option<&mut BTreeMap<Usr, Described<Namespace>>> {
+        self.get_member_namespaces()
+    }
+}
+
+impl<U> NamespaceParentManipulation<Variable> for U
+where
+    U: ClangEntity,
+{
+    fn get_members_mut(&mut self) -> Option<&mut BTreeMap<Usr, Described<Variable>>> {
+        self.get_member_variables()
+    }
+}
+
+impl<U> NamespaceParentManipulation<Function> for U
+where
+    U: ClangEntity,
+{
+    fn get_members_mut(&mut self) -> Option<&mut BTreeMap<Usr, Described<Function>>> {
+        self.get_member_functions()
+    }
+}
+
+impl<U> NamespaceParentManipulation<Struct> for U
+where
+    U: ClangEntity,
+{
+    fn get_members_mut(&mut self) -> Option<&mut BTreeMap<Usr, Described<Struct>>> {
+        self.get_member_structs()
+    }
+}
+
+impl<T: ClangEntity> From<Described<T>> for Entity {
+    fn from(entity: Described<T>) -> Self {
+        let mut children: BTreeMap<ChildrenKind, BTreeMap<EntityId, Entity>> = BTreeMap::new();
+
+        let kind = EntityKind(String::from(entity.entity.kind().to_str_singular()));
+        let clang_children = entity.entity.into_children();
+
+        if let Some(namespaces) = clang_children.namespaces {
+            for (usr, namespace) in namespaces {
+                children
+                    .entry(ChildrenKind(String::from(
+                        namespace.entity.kind().to_str_plural(),
+                    )))
+                    .or_default()
+                    .insert(EntityId(usr.0), namespace.into());
+            }
+        }
+
+        if let Some(variables) = clang_children.variables {
+            for (usr, variable) in variables {
+                children
+                    .entry(ChildrenKind(String::from(
+                        variable.entity.kind().to_str_plural(),
+                    )))
+                    .or_default()
+                    .insert(EntityId(usr.0), variable.into());
+            }
+        }
+
+        if let Some(structs) = clang_children.structs {
+            for (usr, r#struct) in structs {
+                children
+                    .entry(ChildrenKind(String::from(
+                        r#struct.entity.kind().to_str_plural(),
+                    )))
+                    .or_default()
+                    .insert(EntityId(usr.0), r#struct.into());
+            }
+        }
+
+        if let Some(functions) = clang_children.functions {
+            for (usr, function) in functions {
+                children
+                    .entry(ChildrenKind(String::from(
+                        function.entity.kind().to_str_plural(),
+                    )))
+                    .or_default()
+                    .insert(EntityId(usr.0), function.into());
+            }
+        }
+
+        Entity {
+            name: entity.description.name,
+            language: Language::Clang,
+            kind,
+            brief_description: entity.description.brief,
+            documentation: entity.description.detailed,
+            children,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub(super) struct Description {
+    pub(super) name: String,
+    pub(super) brief: String,
+    pub(super) detailed: String,
+}
+
+#[derive(Debug, Clone)]
+pub(super) struct Described<T> {
+    pub(super) description: Description,
+    pub(super) entity: T,
+}
+
+#[derive(Debug, Clone)]
+pub(super) struct Namespace {
+    pub(super) member_namespaces: BTreeMap<Usr, Described<Namespace>>,
+    pub(super) member_variables: BTreeMap<Usr, Described<Variable>>,
+    pub(super) member_structs: BTreeMap<Usr, Described<Struct>>,
+    pub(super) member_functions: BTreeMap<Usr, Described<Function>>,
+}
+
+impl ClangEntity for Namespace {
+    fn kind(&self) -> ClangEntityKind {
+        ClangEntityKind::Namespace
+    }
+
+    fn get_member_namespaces(&mut self) -> Option<&mut BTreeMap<Usr, Described<Namespace>>> {
+        Some(&mut self.member_namespaces)
+    }
+    fn get_member_variables(&mut self) -> Option<&mut BTreeMap<Usr, Described<Variable>>> {
+        Some(&mut self.member_variables)
+    }
+    fn get_member_structs(&mut self) -> Option<&mut BTreeMap<Usr, Described<Struct>>> {
+        Some(&mut self.member_structs)
+    }
+    fn get_member_functions(&mut self) -> Option<&mut BTreeMap<Usr, Described<Function>>> {
+        Some(&mut self.member_functions)
+    }
+
+    fn into_children(self) -> Children {
+        Children {
+            namespaces: Some(self.member_namespaces),
+            variables: Some(self.member_variables),
+            structs: Some(self.member_structs),
+            functions: Some(self.member_functions),
+        }
+    }
+}
+
+/*
+impl FromNamespaceParent for Namespace {
+    fn from_namespace_parent<'a>(
+        parent: &'a mut Described<Namespace>,
+        name: &Usr,
+    ) -> Option<&'a mut Described<Self>> {
+        parent.entity.member_namespaces.get_mut(name)
+    }
+}
+*/
+
+#[derive(Debug, Clone)]
+pub(super) struct Variable {
+    pub(super) kind: VariableKind,
+    pub(super) r#type: String,
+}
+
+impl ClangEntity for Variable {
+    fn kind(&self) -> ClangEntityKind {
+        ClangEntityKind::Variable(self.kind)
+    }
+}
+
+/*
+impl FromNamespaceParent for Variable {
+    fn from_namespace_parent<'a>(
+        parent: &'a mut Described<Namespace>,
+        name: &Usr,
+    ) -> Option<&'a mut Described<Self>> {
+        parent.entity.member_variables.get_mut(name)
+    }
+}
+*/
+
+#[derive(Debug, Clone)]
+pub(super) struct Struct {
+    //pub(super) member_types: Vec<Usr>,
+    pub(super) kind: StructKind,
+    pub(super) member_variables: BTreeMap<Usr, Described<Variable>>,
+    pub(super) member_structs: BTreeMap<Usr, Described<Struct>>,
+    pub(super) member_functions: BTreeMap<Usr, Described<Function>>,
+}
+
+impl ClangEntity for Struct {
+    fn kind(&self) -> ClangEntityKind {
+        ClangEntityKind::Struct(self.kind)
+    }
+
+    fn get_member_variables(&mut self) -> Option<&mut BTreeMap<Usr, Described<Variable>>> {
+        Some(&mut self.member_variables)
+    }
+    fn get_member_structs(&mut self) -> Option<&mut BTreeMap<Usr, Described<Struct>>> {
+        Some(&mut self.member_structs)
+    }
+    fn get_member_functions(&mut self) -> Option<&mut BTreeMap<Usr, Described<Function>>> {
+        Some(&mut self.member_functions)
+    }
+
+    fn into_children(self) -> Children {
+        Children {
+            namespaces: None,
+            variables: Some(self.member_variables),
+            structs: Some(self.member_structs),
+            functions: Some(self.member_functions),
+        }
+    }
+}
+
+/*
+impl FromNamespaceParent for Struct {
+    fn from_namespace_parent<'a>(
+        parent: &'a mut Described<Namespace>,
+        name: &Usr,
+    ) -> Option<&'a mut Described<Self>> {
+        parent.entity.member_structs.get_mut(name)
+    }
+}
+*/
+
+#[derive(Debug, Clone)]
+pub(super) struct Function {
+    pub(super) kind: FunctionKind,
+    pub(super) arguments: Vec<FunctionArgument>,
+    pub(super) return_type: String,
+}
+
+impl ClangEntity for Function {
+    fn kind(&self) -> ClangEntityKind {
+        ClangEntityKind::Function(self.kind)
+    }
+}
+
+/*
+impl FromNamespaceParent for Function {
+    fn from_namespace_parent<'a>(
+        parent: &'a mut Described<Namespace>,
+        name: &Usr,
+    ) -> Option<&'a mut Described<Self>> {
+        parent.entity.member_functions.get_mut(name)
+    }
+}
+*/
+
+#[derive(Debug, Clone)]
+pub(super) struct FunctionArgument {
+    pub(super) name: String,
+    pub(super) r#type: String,
+}