private void updateForSignature(Set<T> signature, @Nullable Map<T, Collection<T>> cache) { HashSet<Set<T>> cyclesResult = new HashSet<>(); Set<T> processed = new HashSet<>(); nodeCache.clearTopNode(); nodeCache.clearBottomNode(); nodeCache.clearNodes(signature); directChildrenOfTopNode.removeAll(signature); Set<T> equivTopOrChildrenOfTop = new HashSet<>(); nodeCache.addNode(cycle); nodeCache.getTopNode().entities().forEach(directChildrenOfTopNode::remove); directParentsOfBottomNode.addAll(equivBottomOrParentsOfBottom); nodeCache.getBottomNode().entities().forEach(directParentsOfBottomNode::remove); Collection<T> parents = rawParentChildProvider.getParents(element); parents.removeAll(node); nodeCache.getTopNode().entities().forEach(parents::remove); if (!parents.isEmpty()) { childOfTop = false; Collection<T> children = rawParentChildProvider.getChildren(element); children.removeAll(node); nodeCache.getBottomNode().entities().forEach(children::remove); if (!children.isEmpty()) { parentOfBottom = false;
public void computeHierarchy() { pm.reasonerTaskStarted("Computing " + name + " hierarchy"); pm.reasonerTaskBusy(); nodeCache.clear(); Map<T, Collection<T>> cache = new HashMap<T, Collection<T>>(); Set<T> entities = new HashSet<T>(); for (OWLOntology ont : getRootOntology().getImportsClosure()) { entities.addAll(getEntities(ont)); } classificationSize = entities.size(); pm.reasonerTaskProgressChanged(0, classificationSize); updateForSignature(entities, cache); pm.reasonerTaskStopped(); }
public NodeSet<T> getNodeHierarchyParents(T child, boolean direct, DefaultNodeSet<T> ns) { Node<T> node = nodeCache.getNode(child); if (node.isTopNode()) { return ns; } Set<T> directParents = new HashSet<T>(); for (T equiv : node) { directParents.addAll(rawParentChildProvider.getParents(equiv)); if(directChildrenOfTopNode.contains(equiv)) { ns.addNode(nodeCache.getTopNode()); } } directParents.removeAll(node.getEntities()); if (node.isBottomNode()) { // Special treatment directParents.addAll(directParentsOfBottomNode); } for (Node<T> parentNode : nodeCache.getNodes(directParents)) { ns.addNode(parentNode); } if (!direct) { for(T parent : directParents) { getNodeHierarchyParents(parent, direct, ns); } } return ns; }
private void updateForSignature(Set<T> signature, Map<T, Collection<T>> cache) { HashSet<Set<T>> cyclesResult = new HashSet<Set<T>>(); Set<T> processed = new HashSet<T>(); nodeCache.clearTopNode(); nodeCache.clearBottomNode(); nodeCache.clearNodes(signature); nodeCache.addNode(cycle); directChildrenOfTopNode.removeAll(nodeCache.getTopNode().getEntities()); directParentsOfBottomNode.removeAll(nodeCache.getBottomNode().getEntities()); Collection<T> parents = rawParentChildProvider.getParents(element); parents.removeAll(node); parents.removeAll(nodeCache.getTopNode().getEntities()); if (!parents.isEmpty()) { childOfTop = false; Collection<T> children = rawParentChildProvider.getChildren(element); children.removeAll(node); children.removeAll(nodeCache.getBottomNode().getEntities()); if (!children.isEmpty()) { parentOfBottom = false;
private void updateForSignature(Set<T> signature, @Nullable Map<T, Collection<T>> cache) { HashSet<Set<T>> cyclesResult = new HashSet<>(); Set<T> processed = new HashSet<>(); nodeCache.clearTopNode(); nodeCache.clearBottomNode(); nodeCache.clearNodes(signature); directChildrenOfTopNode.removeAll(signature); Set<T> equivTopOrChildrenOfTop = new HashSet<>(); nodeCache.addNode(cycle); nodeCache.getTopNode().entities().forEach(directChildrenOfTopNode::remove); directParentsOfBottomNode.addAll(equivBottomOrParentsOfBottom); nodeCache.getBottomNode().entities().forEach(directParentsOfBottomNode::remove); Collection<T> parents = rawParentChildProvider.getParents(element); parents.removeAll(node); nodeCache.getTopNode().entities().forEach(parents::remove); if (!parents.isEmpty()) { childOfTop = false; Collection<T> children = rawParentChildProvider.getChildren(element); children.removeAll(node); nodeCache.getBottomNode().entities().forEach(children::remove); if (!children.isEmpty()) { parentOfBottom = false;
private void updateForSignature(Set<T> signature, @Nullable Map<T, Collection<T>> cache) { HashSet<Set<T>> cyclesResult = new HashSet<>(); Set<T> processed = new HashSet<>(); nodeCache.clearTopNode(); nodeCache.clearBottomNode(); nodeCache.clearNodes(signature); directChildrenOfTopNode.removeAll(signature); Set<T> equivTopOrChildrenOfTop = new HashSet<>(); nodeCache.addNode(cycle); nodeCache.getTopNode().entities().forEach(directChildrenOfTopNode::remove); directParentsOfBottomNode.addAll(equivBottomOrParentsOfBottom); nodeCache.getBottomNode().entities().forEach(directParentsOfBottomNode::remove); Collection<T> parents = rawParentChildProvider.getParents(element); parents.removeAll(node); nodeCache.getTopNode().entities().forEach(parents::remove); if (!parents.isEmpty()) { childOfTop = false; Collection<T> children = rawParentChildProvider.getChildren(element); children.removeAll(node); nodeCache.getBottomNode().entities().forEach(children::remove); if (!children.isEmpty()) { parentOfBottom = false;
private void updateForSignature(Set<T> signature, @Nullable Map<T, Collection<T>> cache) { HashSet<Set<T>> cyclesResult = new HashSet<>(); Set<T> processed = new HashSet<>(); nodeCache.clearTopNode(); nodeCache.clearBottomNode(); nodeCache.clearNodes(signature); directChildrenOfTopNode.removeAll(signature); Set<T> equivTopOrChildrenOfTop = new HashSet<>(); nodeCache.addNode(cycle); nodeCache.getTopNode().entities().forEach(directChildrenOfTopNode::remove); directParentsOfBottomNode.addAll(equivBottomOrParentsOfBottom); nodeCache.getBottomNode().entities().forEach(directParentsOfBottomNode::remove); Collection<T> parents = rawParentChildProvider.getParents(element); parents.removeAll(node); nodeCache.getTopNode().entities().forEach(parents::remove); if (!parents.isEmpty()) { childOfTop = false; Collection<T> children = rawParentChildProvider.getChildren(element); children.removeAll(node); nodeCache.getBottomNode().entities().forEach(children::remove); if (!children.isEmpty()) { parentOfBottom = false;
public NodeSet<T> getNodeHierarchyChildren(T parent, boolean direct, DefaultNodeSet<T> ns) { Node<T> node = nodeCache.getNode(parent); if (node.isBottomNode()) { return ns; } Set<T> directChildren = new HashSet<>(); for (T equiv : node) { directChildren.addAll(rawParentChildProvider.getChildren(equiv)); if (directParentsOfBottomNode.contains(equiv)) { ns.addNode(nodeCache.getBottomNode()); } } node.entities().forEach(directChildren::remove); if (node.isTopNode()) { // Special treatment directChildren.addAll(directChildrenOfTopNode); } for (Node<T> childNode : nodeCache.getNodes(directChildren)) { ns.addNode(childNode); } if (!direct) { for (T child : directChildren) { getNodeHierarchyChildren(child, direct, ns); } } return ns; }
public NodeSet<T> getNodeHierarchyChildren(T parent, boolean direct, DefaultNodeSet<T> ns) { Node<T> node = nodeCache.getNode(parent); if (node.isBottomNode()) { return ns; } Set<T> directChildren = new HashSet<T>(); for (T equiv : node) { directChildren.addAll(rawParentChildProvider.getChildren(equiv)); if(directParentsOfBottomNode.contains(equiv)) { ns.addNode(nodeCache.getBottomNode()); } } directChildren.removeAll(node.getEntities()); if (node.isTopNode()) { // Special treatment directChildren.addAll(directChildrenOfTopNode); } for (Node<T> childNode : nodeCache.getNodes(directChildren)) { ns.addNode(childNode); } if (!direct) { for (T child : directChildren) { getNodeHierarchyChildren(child, direct, ns); } } return ns; }
public NodeSet<T> getNodeHierarchyParents(T child, boolean direct, DefaultNodeSet<T> ns) { Node<T> node = nodeCache.getNode(child); if (node.isTopNode()) { return ns; } Set<T> directParents = new HashSet<>(); for (T equiv : node) { directParents.addAll(rawParentChildProvider.getParents(equiv)); if (directChildrenOfTopNode.contains(equiv)) { ns.addNode(nodeCache.getTopNode()); } } node.entities().forEach(directParents::remove); if (node.isBottomNode()) { // Special treatment directParents.addAll(directParentsOfBottomNode); } for (Node<T> parentNode : nodeCache.getNodes(directParents)) { ns.addNode(parentNode); } if (!direct) { for (T parent : directParents) { getNodeHierarchyParents(parent, direct, ns); } } return ns; }
public NodeSet<T> getNodeHierarchyParents(T child, boolean direct, DefaultNodeSet<T> ns) { Node<T> node = nodeCache.getNode(child); if (node.isTopNode()) { return ns; } Set<T> directParents = new HashSet<>(); for (T equiv : node) { directParents.addAll(rawParentChildProvider.getParents(equiv)); if (directChildrenOfTopNode.contains(equiv)) { ns.addNode(nodeCache.getTopNode()); } } node.entities().forEach(directParents::remove); if (node.isBottomNode()) { // Special treatment directParents.addAll(directParentsOfBottomNode); } for (Node<T> parentNode : nodeCache.getNodes(directParents)) { ns.addNode(parentNode); } if (!direct) { for (T parent : directParents) { getNodeHierarchyParents(parent, direct, ns); } } return ns; }
public NodeSet<T> getNodeHierarchyParents(T child, boolean direct, DefaultNodeSet<T> ns) { Node<T> node = nodeCache.getNode(child); if (node.isTopNode()) { return ns; } Set<T> directParents = new HashSet<>(); for (T equiv : node) { directParents.addAll(rawParentChildProvider.getParents(equiv)); if (directChildrenOfTopNode.contains(equiv)) { ns.addNode(nodeCache.getTopNode()); } } node.entities().forEach(directParents::remove); if (node.isBottomNode()) { // Special treatment directParents.addAll(directParentsOfBottomNode); } for (Node<T> parentNode : nodeCache.getNodes(directParents)) { ns.addNode(parentNode); } if (!direct) { for (T parent : directParents) { getNodeHierarchyParents(parent, direct, ns); } } return ns; }
public NodeSet<T> getNodeHierarchyChildren(T parent, boolean direct, DefaultNodeSet<T> ns) { Node<T> node = nodeCache.getNode(parent); if (node.isBottomNode()) { return ns; } Set<T> directChildren = new HashSet<>(); for (T equiv : node) { directChildren.addAll(rawParentChildProvider.getChildren(equiv)); if (directParentsOfBottomNode.contains(equiv)) { ns.addNode(nodeCache.getBottomNode()); } } node.entities().forEach(directChildren::remove); if (node.isTopNode()) { // Special treatment directChildren.addAll(directChildrenOfTopNode); } for (Node<T> childNode : nodeCache.getNodes(directChildren)) { ns.addNode(childNode); } if (!direct) { for (T child : directChildren) { getNodeHierarchyChildren(child, direct, ns); } } return ns; }
public NodeSet<T> getNodeHierarchyChildren(T parent, boolean direct, DefaultNodeSet<T> ns) { Node<T> node = nodeCache.getNode(parent); if (node.isBottomNode()) { return ns; } Set<T> directChildren = new HashSet<>(); for (T equiv : node) { directChildren.addAll(rawParentChildProvider.getChildren(equiv)); if (directParentsOfBottomNode.contains(equiv)) { ns.addNode(nodeCache.getBottomNode()); } } node.entities().forEach(directChildren::remove); if (node.isTopNode()) { // Special treatment directChildren.addAll(directChildrenOfTopNode); } for (Node<T> childNode : nodeCache.getNodes(directChildren)) { ns.addNode(childNode); } if (!direct) { for (T child : directChildren) { getNodeHierarchyChildren(child, direct, ns); } } return ns; }
public NodeSet<T> getNodeHierarchyParents(T child, boolean direct, DefaultNodeSet<T> ns) { Node<T> node = nodeCache.getNode(child); if (node.isTopNode()) { return ns; } Set<T> directParents = new HashSet<>(); for (T equiv : node) { directParents.addAll(rawParentChildProvider.getParents(equiv)); if (directChildrenOfTopNode.contains(equiv)) { ns.addNode(nodeCache.getTopNode()); } } node.entities().forEach(directParents::remove); if (node.isBottomNode()) { // Special treatment directParents.addAll(directParentsOfBottomNode); } for (Node<T> parentNode : nodeCache.getNodes(directParents)) { ns.addNode(parentNode); } if (!direct) { for (T parent : directParents) { getNodeHierarchyParents(parent, direct, ns); } } return ns; }
public NodeSet<T> getNodeHierarchyChildren(T parent, boolean direct, DefaultNodeSet<T> ns) { Node<T> node = nodeCache.getNode(parent); if (node.isBottomNode()) { return ns; } Set<T> directChildren = new HashSet<>(); for (T equiv : node) { directChildren.addAll(rawParentChildProvider.getChildren(equiv)); if (directParentsOfBottomNode.contains(equiv)) { ns.addNode(nodeCache.getBottomNode()); } } node.entities().forEach(directChildren::remove); if (node.isTopNode()) { // Special treatment directChildren.addAll(directChildrenOfTopNode); } for (Node<T> childNode : nodeCache.getNodes(directChildren)) { ns.addNode(childNode); } if (!direct) { for (T child : directChildren) { getNodeHierarchyChildren(child, direct, ns); } } return ns; }
public void addNode(Set<T> elements) { addNode(hierarchyInfo.createNode(elements)); }
public void addNode(Set<T> elements) { addNode(hierarchyInfo.createNode(elements)); }
public void addNode(Set<T> elements) { addNode(hierarchyInfo.createNode(elements)); }
public Node<T> getEquivalents(T element) { return nodeCache.getNode(element); } }