diff --git a/.classpath b/.classpath
index 002ad57..8131be0 100644
--- a/.classpath
+++ b/.classpath
@@ -6,11 +6,6 @@
-
-
-
-
-
diff --git a/src/main/java/org/gcube/informationsystem/utils/documentation/generator/ClassesDiscoveryGenerator.java b/src/main/java/org/gcube/informationsystem/utils/documentation/generator/ClassesDiscoveryGenerator.java
index 791401f..9a99451 100644
--- a/src/main/java/org/gcube/informationsystem/utils/documentation/generator/ClassesDiscoveryGenerator.java
+++ b/src/main/java/org/gcube/informationsystem/utils/documentation/generator/ClassesDiscoveryGenerator.java
@@ -18,6 +18,7 @@ import org.gcube.informationsystem.utils.discovery.RegistrationProvider;
*/
public class ClassesDiscoveryGenerator {
+ protected TreeGenerator treeGenerator;
protected TypeListGenerator typeListGenerator;
public ClassesDiscoveryGenerator() {
@@ -62,12 +63,12 @@ public class ClassesDiscoveryGenerator {
for(Class extends E> clz : discovery.getDiscovered()) {
Type type = TypeMapper.createTypeDefinition(clz);
- typeListGenerator.addType(type);
+ treeGenerator.addType(type);
}
}
protected void generate(Package[] packages) throws Exception {
- typeListGenerator = new TypeListGenerator();
+ treeGenerator = new TreeGenerator();
AccessType[] types = new AccessType[] {
AccessType.PROPERTY,
AccessType.RESOURCE, AccessType.FACET,
@@ -75,8 +76,6 @@ public class ClassesDiscoveryGenerator {
for(AccessType at : types) {
discover(at, packages);
}
-
- typeListGenerator.generate();
-
+ treeGenerator.generate();
}
}
diff --git a/src/main/java/org/gcube/informationsystem/utils/documentation/generator/TreeGenerator.java b/src/main/java/org/gcube/informationsystem/utils/documentation/generator/TreeGenerator.java
new file mode 100644
index 0000000..b193d9a
--- /dev/null
+++ b/src/main/java/org/gcube/informationsystem/utils/documentation/generator/TreeGenerator.java
@@ -0,0 +1,78 @@
+package org.gcube.informationsystem.utils.documentation.generator;
+
+import java.util.Map;
+import java.util.TreeMap;
+
+import org.gcube.informationsystem.base.reference.AccessType;
+import org.gcube.informationsystem.types.TypeMapper;
+import org.gcube.informationsystem.types.reference.Type;
+import org.gcube.informationsystem.utils.documentation.knowledge.Tree;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * @author Luca Frosini (ISTI - CNR)
+ */
+public class TreeGenerator {
+
+ private static final Logger logger = LoggerFactory.getLogger(TreeGenerator.class);
+
+ protected Map types;
+
+ public TreeGenerator() {
+ types = new TreeMap<>();
+ }
+
+ public void addType(Type type) {
+ AccessType accessType = type.getAccessType();
+ if(types.get(accessType)==null) {
+ Type head = TypeMapper.createTypeDefinition(accessType.getTypeClass());
+ Tree tree = new Tree(head);
+ types.put(accessType, tree);
+ }
+ if(type.getName().compareTo(accessType.getName())==0) {
+ return;
+ }
+ Tree tree = types.get(accessType);
+ tree.addNode(type);
+ }
+
+
+ public void elaborateTree(AccessType at, Tree tree) {
+ logger.info("\n{}", tree.toString());
+
+// elaborateList(propertyTypes);
+//
+// File f = getFile(ENTITIES_FILENAME, true);
+// DocumentationGenerator edg = new EntityDocumentationGenerator(TypeMapper.createTypeDefinition(Entity.class));
+// edg.setOffsetLevel(offsetLevel);
+// StringBuffer sb = edg.generateSection();
+// Files.write(f.toPath(), sb.toString().getBytes(), StandardOpenOption.APPEND);
+//
+// elaborateList(resourceTypes);
+// elaborateList(facetTypes);
+//
+// f = getFile(RELATIONS_FILENAME, true);
+// DocumentationGenerator rdg = new RelationDocumentationGenerator(TypeMapper.createTypeDefinition(Relation.class));
+// rdg.setOffsetLevel(offsetLevel);
+// sb = rdg.generateSection();
+// Files.write(f.toPath(), sb.toString().getBytes(), StandardOpenOption.APPEND);
+//
+// elaborateList(isRelatedToTypes);
+// elaborateList(consistsOfTypes);
+ }
+
+ public void generate() throws Exception {
+
+ AccessType[] accessTypes = new AccessType[] {
+ AccessType.PROPERTY,
+ AccessType.RESOURCE, AccessType.FACET,
+ AccessType.CONSISTS_OF, AccessType.IS_RELATED_TO};
+ for(AccessType at : accessTypes) {
+ Tree tree = types.get(at);
+ elaborateTree(at, tree);
+ }
+
+ }
+
+}
diff --git a/src/main/java/org/gcube/informationsystem/utils/documentation/knowledge/Node.java b/src/main/java/org/gcube/informationsystem/utils/documentation/knowledge/Node.java
new file mode 100644
index 0000000..b2830fb
--- /dev/null
+++ b/src/main/java/org/gcube/informationsystem/utils/documentation/knowledge/Node.java
@@ -0,0 +1,99 @@
+package org.gcube.informationsystem.utils.documentation.knowledge;
+
+import java.util.Set;
+import java.util.TreeSet;
+
+import org.gcube.informationsystem.types.reference.Type;
+
+/**
+ * @author Luca Frosini (ISTI - CNR)
+ */
+public class Node implements Comparable {
+
+ public static String INDENTATION = "\t";
+
+ private Type type;
+
+ private Tree tree;
+
+ private Node parent;
+ private Set children;
+
+ public Node(Type type) {
+ this.type = type;
+ this.children = new TreeSet();
+ }
+
+ public Tree getTree() {
+ return tree;
+ }
+
+ private void setTree(Tree tree) {
+ this.tree = tree;
+ }
+
+ public Type getType() {
+ return type;
+ }
+
+ public Node getParent() {
+ return parent;
+ }
+
+ public Node setParent(Node parent) {
+ this.parent = parent;
+ return this;
+ }
+
+ public Node addChild(Node child) {
+ children.add(child);
+ child.setParent(this);
+ child.setTree(tree);
+ return this;
+ }
+
+ public Set getChildrenNodes() {
+ return children;
+ }
+
+ public Set getChildren() {
+ Set sortedChildren = new TreeSet<>();
+ for (Node treeNode : children) {
+ sortedChildren.add(treeNode.type);
+ }
+ return sortedChildren;
+ }
+
+ @Override
+ public String toString() {
+ return createTree(0).toString();
+ }
+
+ private StringBuffer createTree(int level) {
+ StringBuffer stringBuffer = new StringBuffer();
+ for (int i = 0; i < level; ++i) {
+ stringBuffer.append(Node.INDENTATION);
+ }
+ stringBuffer.append(type.getName());
+ for (Node child : children) {
+ stringBuffer.append("\n");
+ stringBuffer.append(child.createTree(level+1));
+ }
+ return stringBuffer;
+ }
+
+ @Override
+ public int compareTo(Node other) {
+ if (this == other) {
+ return 0;
+ }
+ if (other == null) {
+ return -1;
+ }
+ if (getClass() != other.getClass()) {
+ return -1;
+ }
+
+ return type.getName().compareTo(other.type.getName());
+ }
+}
diff --git a/src/main/java/org/gcube/informationsystem/utils/documentation/knowledge/Tree.java b/src/main/java/org/gcube/informationsystem/utils/documentation/knowledge/Tree.java
index 15d6822..246ff9f 100644
--- a/src/main/java/org/gcube/informationsystem/utils/documentation/knowledge/Tree.java
+++ b/src/main/java/org/gcube/informationsystem/utils/documentation/knowledge/Tree.java
@@ -1,109 +1,54 @@
package org.gcube.informationsystem.utils.documentation.knowledge;
-import java.util.ArrayList;
-import java.util.Collection;
import java.util.HashMap;
-import java.util.List;
+import java.util.Set;
+
+import org.gcube.informationsystem.types.reference.Type;
/**
- * @author ycoppel@google.com (Yohann Coppel)
- *
- * @param Object's type in the tree.
+ * @author Luca Frosini (ISTI - CNR)
*/
-public class Tree {
+public class Tree {
- private T head;
- private List> leafs;
- private Tree parent = null;
-
- private HashMap> locate = new HashMap>();
-
- public Tree(T head) {
- this.head = head;
- this.leafs = new ArrayList>();
- locate.put(head, this);
+ private Node root;
+
+ private boolean allowMultipleInheritance;
+ private HashMap locate = new HashMap();
+
+
+ public Tree(Type head) {
+ this.root = new Node(head);
+ this.locate.put(head.getName(), root);
+ this.allowMultipleInheritance = false;
}
-
- public void addLeaf(T parent, T leaf) {
- if (locate.containsKey(parent)) {
- locate.get(parent).addLeaf(leaf);
- } else {
- addLeaf(parent).addLeaf(leaf);
- }
+
+ public void setAllowMultipleInheritance(boolean allowMultipleInheritance) {
+ this.allowMultipleInheritance = allowMultipleInheritance;
}
-
- public Tree addLeaf(T leaf) {
- Tree t = new Tree(leaf);
- leafs.add(t);
- t.parent = this;
- t.locate = this.locate;
- locate.put(leaf, t);
- return t;
- }
-
- public Tree setAsParent(T parentRoot) {
- Tree t = new Tree(parentRoot);
- t.leafs.add(this);
- this.parent = t;
- t.locate = this.locate;
- t.locate.put(head, this);
- t.locate.put(parentRoot, t);
- return t;
- }
-
- public T getHead() {
- return head;
- }
-
- public Tree getTree(T element) {
- return locate.get(element);
- }
-
- public Tree getParent() {
- return parent;
- }
-
- public Collection getSuccessors(T root) {
- Collection successors = new ArrayList();
- Tree tree = getTree(root);
- if (null != tree) {
- for (Tree leaf : tree.leafs) {
- successors.add(leaf.head);
+
+ public void addNode(Type t) {
+ Set superClasses = t.getSuperClasses();
+ for(String superClass : superClasses) {
+ Node parent = locate.get(superClass);
+ if(parent==null) {
+ throw new RuntimeException("I can find parent Node for " + t.getName() + ". Missing parent is " + superClass);
+ }
+ Node node = new Node(t);
+ parent.addChild(node);
+ locate.put(t.getName(), node);
+ if(!allowMultipleInheritance) {
+ return;
}
}
- return successors;
}
- public Collection> getSubTrees() {
- return leafs;
- }
-
- public static Collection getSuccessors(T of, Collection> in) {
- for (Tree tree : in) {
- if (tree.locate.containsKey(of)) {
- return tree.getSuccessors(of);
- }
- }
- return new ArrayList();
+ public Node getRoot() {
+ return root;
}
@Override
public String toString() {
- return printTree(0);
+ return root.toString();
}
- private static final int indent = 2;
-
- private String printTree(int increment) {
- String s = "";
- String inc = "";
- for (int i = 0; i < increment; ++i) {
- inc = inc + " ";
- }
- s = inc + head;
- for (Tree child : leafs) {
- s += "\n" + child.printTree(increment + indent);
- }
- return s;
- }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/org/gcube/informationsystem/utils/documentation/knowledge/TypesKnowledge.java b/src/main/java/org/gcube/informationsystem/utils/documentation/knowledge/TypesKnowledge.java
deleted file mode 100644
index 9ecc33b..0000000
--- a/src/main/java/org/gcube/informationsystem/utils/documentation/knowledge/TypesKnowledge.java
+++ /dev/null
@@ -1,45 +0,0 @@
-package org.gcube.informationsystem.utils.documentation.knowledge;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.gcube.informationsystem.types.reference.Type;
-
-public class TypesKnowledge {
-
- protected Map typeByName;
- protected Map> typesByLevels;
- protected Map levelOfTypes;
- protected Map> children;
-
- public TypesKnowledge() {
- this.typeByName = new HashMap<>();
- this.typesByLevels = new HashMap<>();
- this.levelOfTypes = new HashMap<>();
- this.children = new HashMap<>();
- }
-
- public void addType(T type) {
- typeByName.put(type.getName(), type);
- Set superClasses = type.getSuperClasses();
- for(String superClass : superClasses) {
-
- }
- }
-
- public Set getTypesByLevel(int level) {
- return typesByLevels.get(level);
- }
-
- public int getTypeLevel(Type type) {
- return getTypeLevel(type.getName());
- }
-
- public int getTypeLevel(String typeName) {
- return levelOfTypes.get(typeName);
- }
-
-
-}