From a7e597fbd4d241a2c9c288039e5d488767d5cb72 Mon Sep 17 00:00:00 2001 From: Luca Frosini Date: Mon, 23 Jan 2023 16:21:01 +0100 Subject: [PATCH] Improved solution --- .classpath | 5 - .../generator/ClassesDiscoveryGenerator.java | 9 +- .../generator/TreeGenerator.java | 78 +++++++++++ .../utils/documentation/knowledge/Node.java | 99 ++++++++++++++ .../utils/documentation/knowledge/Tree.java | 125 +++++------------- .../knowledge/TypesKnowledge.java | 45 ------- 6 files changed, 216 insertions(+), 145 deletions(-) create mode 100644 src/main/java/org/gcube/informationsystem/utils/documentation/generator/TreeGenerator.java create mode 100644 src/main/java/org/gcube/informationsystem/utils/documentation/knowledge/Node.java delete mode 100644 src/main/java/org/gcube/informationsystem/utils/documentation/knowledge/TypesKnowledge.java 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 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); - } - - -}