/*
Copyright 2008-2010 Gephi
Authors : Mathieu Bastian <mathieu.bastian@gephi.org>
Website : http://www.gephi.org
This file is part of Gephi.
Gephi is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
Gephi is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with Gephi. If not, see <http://www.gnu.org/licenses/>.
*/
package org.gephi.graph.dhns.graph;
import org.gephi.graph.api.Edge;
import org.gephi.graph.api.HierarchicalGraph;
import org.gephi.graph.api.ImmutableTreeNode;
import org.gephi.graph.api.Node;
import org.gephi.graph.api.NodeIterable;
import org.gephi.graph.dhns.core.Dhns;
import org.gephi.graph.dhns.core.GraphViewImpl;
import org.gephi.graph.dhns.edge.AbstractEdge;
import org.gephi.graph.dhns.node.AbstractNode;
import org.gephi.graph.dhns.node.iterators.ChildrenIterator;
import org.gephi.graph.dhns.node.iterators.DescendantIterator;
import org.gephi.graph.dhns.node.iterators.LevelIterator;
import org.gephi.graph.dhns.node.iterators.TreeIterator;
import org.gephi.graph.dhns.predicate.Predicate;
import org.gephi.graph.dhns.predicate.Tautology;
import org.gephi.graph.dhns.utils.TreeNodeWrapper;
/**
*
* @author Mathieu Bastian
*/
public abstract class HierarchicalGraphImpl extends AbstractGraphImpl implements HierarchicalGraph {
protected Predicate<AbstractNode> enabledNodePredicate;
public HierarchicalGraphImpl(Dhns dhns, GraphViewImpl view) {
super(dhns, view);
enabledNodePredicate = new Predicate<AbstractNode>() {
public boolean evaluate(AbstractNode element) {
return element.isEnabled();
}
};
}
public abstract HierarchicalGraphImpl copy(Dhns dhns, GraphViewImpl view);
public boolean addNode(Node node, Node parent) {
if (node == null) {
throw new IllegalArgumentException("Node can't be null");
}
AbstractNode absNode = (AbstractNode) node;
AbstractNode absParent = null;
if (parent != null) {
absParent = checkNode(parent);
}
if (absNode.isValid(view.getViewId())) {
return false;
}
if (absNode.avlNode != null) { //exist in another view
if (absNode.getInView(view.getViewId()) != null) {
return false;
}
absNode = new AbstractNode(absNode.getNodeData(), view.getViewId());
}
if (!absNode.getNodeData().hasAttributes()) {
absNode.getNodeData().setAttributes(dhns.factory().newNodeAttributes(absNode.getNodeData()));
}
view.getStructureModifier().addNode(absNode, absParent);
return true;
}
public boolean addNode(Node node) {
return addNode(node, null);
}
public boolean contains(Node node) {
if (node == null) {
throw new NullPointerException();
}
AbstractNode absNode = (AbstractNode) node;
boolean res = false;
if (absNode.isValid(view.getViewId())) {
res = structure.getTree().contains(absNode);
} else if ((absNode = absNode.getInView(view.getViewId())) != null) {
res = true;
}
return res;
}
public Node getNode(int id) {
return dhns.getGraphStructure().getNodeFromDictionnary(id, view.getViewId());
}
public Edge getEdge(int id) {
return dhns.getGraphStructure().getEdgeFromDictionnary(id);
}
public Node getNode(String id) {
if (id == null) {
throw new NullPointerException();
}
return dhns.getGraphStructure().getNodeFromDictionnary(id, view.getViewId());
}
public Edge getEdge(String id) {
if (id == null) {
throw new NullPointerException();
}
return dhns.getGraphStructure().getEdgeFromDictionnary(id);
}
public NodeIterable getNodes() {
readLock();
return dhns.newNodeIterable(new TreeIterator(structure, true, Tautology.instance));
}
public NodeIterable getNodesTree() {
readLock();
return dhns.newNodeIterable(new TreeIterator(structure, false, Tautology.instance));
}
public int getNodeCount() {
//int count = structure.getTreeSize() - 1;// -1 Exclude virtual root
int count = view.getNodesEnabled();
return count;
}
public NodeIterable getNodes(int level) {
level += 1; //Because we ignore the virtual root
readLock();
int height = structure.getTreeHeight();
if (level > height) {
readUnlock();
throw new IllegalArgumentException("Level must be between 0 and the height of the tree, currently height=" + (height - 1));
}
return dhns.newNodeIterable(new LevelIterator(structure, level, Tautology.instance));
}
public int getLevelSize(int level) {
level += 1; //Because we ignore the virtual root
int height = structure.getTreeHeight();
if (level > height) {
throw new IllegalArgumentException("Level must be between 0 and the height of the tree, currently height=" + (height - 1));
}
int res = structure.getLevelSize(level);
return res;
}
public boolean isSelfLoop(Edge edge) {
AbstractEdge absEdge = checkEdge(edge);
return absEdge.getSource(view.getViewId()) == absEdge.getTarget(view.getViewId());
}
public boolean isAdjacent(Edge edge1, Edge edge2) {
if (edge1 == edge2) {
throw new IllegalArgumentException("Edges can't be the same");
}
AbstractEdge absEdge1 = checkEdge(edge1);
AbstractEdge absEdge2 = checkEdge(edge2);
return absEdge1.getSource(view.getViewId()) == absEdge2.getSource(view.getViewId())
|| absEdge1.getSource(view.getViewId()) == absEdge2.getTarget(view.getViewId())
|| absEdge1.getTarget(view.getViewId()) == absEdge2.getSource(view.getViewId())
|| absEdge1.getTarget(view.getViewId()) == absEdge2.getTarget(view.getViewId());
}
public Node getOpposite(Node node, Edge edge) {
checkNode(node);
AbstractEdge absEdge = checkEdgeOrMetaEdge(edge);
if (absEdge.getSource(view.getViewId()) == node) {
return absEdge.getTarget(view.getViewId());
} else if (absEdge.getTarget(view.getViewId()) == node) {
return absEdge.getSource(view.getViewId());
}
throw new IllegalArgumentException("Node must be either source or target of the edge.");
}
public boolean removeNode(Node node) {
AbstractNode absNode = checkNode(node);
view.getStructureModifier().deleteNode(absNode);
return true;
}
public void clear() {
view.getStructureModifier().clear();
}
public void clearEdges() {
view.getStructureModifier().clearEdges();
}
public void clearEdges(Node node) {
AbstractNode absNode = checkNode(node);
view.getStructureModifier().clearEdges(absNode);
}
public void clearMetaEdges(Node node) {
AbstractNode absNode = checkNode(node);
view.getStructureModifier().clearMetaEdges(absNode);
}
public void setId(Node node, String id) {
if (node == null) {
throw new NullPointerException("node can't be null");
}
dhns.getGraphStructure().setNodeId(((AbstractNode) node).getNodeData(), id);
}
public void setId(Edge edge, String id) {
if (edge == null) {
throw new NullPointerException("edge can't be null");
}
dhns.getGraphStructure().setEdgeId((AbstractEdge) edge, id);
}
public ImmutableTreeNode wrapToTreeNode() {
TreeNodeWrapper wrapper = new TreeNodeWrapper(structure);
ImmutableTreeNode treeNode;
readLock();
treeNode = wrapper.wrap(new TreeIterator(structure, false, Tautology.instance));
readUnlock();
return treeNode;
}
public int getChildrenCount(Node node) {
AbstractNode absNode = checkNode(node);
int count = 0;
ChildrenIterator itr = new ChildrenIterator(structure, absNode, Tautology.instance);
for (; itr.hasNext();) {
itr.next();
count++;
}
return count;
}
public int getDescendantCount(Node node) {
AbstractNode absNode = checkNode(node);
return absNode.size;
}
public Node getParent(Node node) {
AbstractNode absNode = checkNode(node);
Node parent = null;
if (absNode.parent != structure.getRoot()) {
parent = absNode.parent;
}
return parent;
}
public NodeIterable getChildren(Node node) {
readLock();
AbstractNode absNode = checkNode(node);
return dhns.newNodeIterable(new ChildrenIterator(structure, absNode, Tautology.instance));
}
public NodeIterable getDescendant(Node node) {
readLock();
AbstractNode absNode = checkNode(node);
return dhns.newNodeIterable(new DescendantIterator(structure, absNode, Tautology.instance));
}
public NodeIterable getTopNodes() {
readLock();
return dhns.newNodeIterable(new ChildrenIterator(structure, Tautology.instance));
}
public boolean isDescendant(Node node, Node descendant) {
AbstractNode absNode = checkNode(node);
AbstractNode absDesc = checkNode(descendant);
boolean res = false;
res = absDesc.getPre() > absNode.getPre() && absDesc.getPost() < absNode.getPost();
return res;
}
public boolean isAncestor(Node node, Node ancestor) {
return isDescendant(ancestor, node);
}
public boolean isFollowing(Node node, Node following) {
AbstractNode absNode = checkNode(node);
AbstractNode absFoll = checkNode(following);
boolean res = absFoll.getPre() > absNode.getPre() && absFoll.getPost() > absNode.getPost();
return res;
}
public boolean isPreceding(Node node, Node preceding) {
return isFollowing(preceding, node);
}
public boolean isParent(Node node, Node parent) {
AbstractNode absNode = checkNode(node);
AbstractNode absParent = checkNode(parent);
boolean res = absNode.parent == absParent;
return res;
}
public int getHeight() {
int res = structure.getTreeHeight() - 1;
return res;
}
public int getLevel(Node node) {
AbstractNode absNode = checkNode(node);
int res = absNode.level - 1;
return res;
}
public void moveToGroup(Node node, Node nodeGroup) {
AbstractNode absNode = checkNode(node);
AbstractNode absGroup = checkNode(nodeGroup);
if (isDescendant(absNode, absGroup)) {
throw new IllegalArgumentException("nodeGroup can't be a descendant of node");
}
view.getStructureModifier().moveToGroup(absNode, absGroup);
}
public void removeFromGroup(Node node) {
AbstractNode absNode = checkNode(node);
if (absNode.parent.parent == null) { //Equal root
throw new IllegalArgumentException("Node parent can't be the root of the tree");
}
view.getStructureModifier().moveToGroup(absNode, absNode.parent.parent);
}
public Node groupNodes(Node[] nodes) {
if (nodes == null || nodes.length == 0) {
throw new IllegalArgumentException("nodes can't be null or empty");
}
AbstractNode[] absNodes = new AbstractNode[nodes.length];
AbstractNode parent = null;
for (int i = 0; i < nodes.length; i++) {
AbstractNode node = checkNode(nodes[i]);
absNodes[i] = node;
if (parent == null) {
parent = node.parent;
} else if (parent != node.parent) {
throw new IllegalArgumentException("All nodes must have the same parent");
}
}
Node group = view.getStructureModifier().group(absNodes);
return group;
}
public void ungroupNodes(Node nodeGroup) {
AbstractNode absNode = checkNode(nodeGroup);
if (absNode.size == 0) {
throw new IllegalArgumentException("nodeGroup can't be empty");
}
view.getStructureModifier().ungroup(absNode);
}
public boolean expand(Node node) {
AbstractNode absNode = checkNode(node);
if (absNode.size == 0 || !absNode.isEnabled()) {
return false;
}
view.getStructureModifier().expand(absNode);
return true;
}
public boolean retract(Node node) {
AbstractNode absNode = checkNode(node);
if (absNode.size == 0 || absNode.isEnabled()) {
return false;
}
view.getStructureModifier().retract(absNode);
return true;
}
public boolean isInView(Node node) {
AbstractNode absNode = checkNode(node);
boolean res = absNode.isEnabled();
return res;
}
public void resetViewToLeaves() {
view.getStructureModifier().resetViewToLeaves();
}
public void resetViewToLevel(int level) {
readLock();
level += 1; //Because we ignore the virtual root
int height = structure.getTreeHeight();
if (level > height) {
readUnlock();
throw new IllegalArgumentException("Level must be between 0 and the height of the tree, currently height=" + (height - 1));
}
readUnlock();
view.getStructureModifier().resetViewToLevel(level);
}
public void resetViewToTopNodes() {
view.getStructureModifier().resetViewToTopNodes();
}
public void flatten() {
view.getStructureModifier().flatten();
}
}