X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=org.simantics.interop.mapping%2Fsrc%2Forg%2Fsimantics%2Finterop%2Fmapping%2Fdata%2FGraphNode.java;fp=org.simantics.interop.mapping%2Fsrc%2Forg%2Fsimantics%2Finterop%2Fmapping%2Fdata%2FGraphNode.java;h=c775e8b1c68e62df7b1f0c6d2f1976b721703b7d;hb=bd7152b9aaac10befa93c6c1fd9e4f1f9fd15c4a;hp=0000000000000000000000000000000000000000;hpb=c2f8c678f5160b4c3fd235025eaddc5735099942;p=simantics%2Finterop.git

diff --git a/org.simantics.interop.mapping/src/org/simantics/interop/mapping/data/GraphNode.java b/org.simantics.interop.mapping/src/org/simantics/interop/mapping/data/GraphNode.java
new file mode 100644
index 0000000..c775e8b
--- /dev/null
+++ b/org.simantics.interop.mapping/src/org/simantics/interop/mapping/data/GraphNode.java
@@ -0,0 +1,820 @@
+package org.simantics.interop.mapping.data;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.simantics.interop.mapping.Logger;
+import org.simantics.utils.datastructures.hints.HintContext;
+
+
+/**
+ * 
+ * 
+ * @author Marko Luukkainen <marko.luukkainen@vtt.fi>
+ *
+ * @param <T>
+ */
+public class GraphNode<T> extends HintContext {
+	protected T data;
+	private List<Link<T>> nodes = new ArrayList<Link<T>>();
+
+	private boolean disposed = false;
+	
+	public GraphNode(T data) {
+		this.data = data;
+	}
+	
+	/**
+	 * Returns data.
+	 * @return
+	 */
+	public T getData() {
+		return data;
+	}
+
+	
+	@Override
+    public void setHint(Key key, Object value) {
+		_checkDisposed();
+		if (value == null)
+			return;	
+		super.setHint(key, value);
+	}
+	
+	
+	
+	
+	/**
+	 * Adds link to the other node.
+	 * @param relationName name of the link from this node to the other node.
+	 * @param inverseRelationName nam,e of the link from the other node to this node.
+	 * @param node the other node.
+	 * @return the created link. Returns null if the link cannot be created.
+	 */
+	public Link<T> addLink(String relationName, String inverseRelationName,GraphNode<T> node) {
+		_checkDisposed();
+		Logger.defaultLogInfo("Node link " + data + " " + node.data + " " + relationName + " " + inverseRelationName +"\n");
+		if(containsLink(relationName, node) && node.containsLink(inverseRelationName, this)) {
+			Logger.defaultLogWarning("Node " + getData() + " has already given child " +  node.getData() + " ,with name " + relationName + " / " + inverseRelationName);
+			return null;
+		}
+		Link<T> rel = _addLink(relationName,node);
+		Link<T> inv = node._addLink(inverseRelationName,this);
+		rel.setInverseLink(inv);
+		inv.setMainLink(rel);
+		return rel;
+	}
+	
+	/**
+	 * Adds link to the other node, with <pre>null</pre> link name from the other node to this node.
+	 * @param relationName
+	 * @param node name of the link from this node to the other node
+	 * @return the created link. Returns null if the link cannot be created.
+	 */
+	public Link<T> addLink(String relationName,GraphNode<T> node) {
+		_checkDisposed();
+		if(containsLink(relationName, node)) {
+			Logger.defaultLogWarning("Node " + getData() + " has already given child " +  node.getData() + " ,with name " + relationName );
+			return null;
+		}
+		Link<T> rel = _addLink(relationName,node);
+		Link<T> inv = node._addLink(null,this);
+		rel.setInverseLink(inv);
+		inv.setMainLink(rel);
+		return rel;
+	}
+	
+	/**
+	 * Adds link to the other node, with copying link properties from given link.
+	 * @param link
+	 * @param node name of the link from this node to the other node
+	 * @return the created link. Returns null if the link cannot be created.
+	 */
+	public Link<T> addLink(Link<T> link ,GraphNode<T> node) {
+		_checkDisposed();
+		if(containsLink(link.getName(), node) && node.containsLink(link.getInverseName(), this)) {
+			Logger.defaultLogWarning("Node " + getData() + " has already given child " +  node.getData() + " ,with name " + link.getName() + " / " + link.getInverseName());
+			return null;
+		}
+		Link<T> rel = _addLink(link.getName(),node);
+		Link<T> inv = node._addLink(link.getInverseName(),this);
+		rel.setInverseLink(inv);
+		inv.setMainLink(rel);
+		rel.setHints(link.getHints());
+		inv.setHints(link.getInverse().getHints());
+		return rel;
+	}
+	
+	protected Link<T> _addLink(String relation,  GraphNode<T> node) {
+		Link<T> link = new Link<T>(this, relation,node);
+		nodes.add(link);
+		return link;
+	}
+	
+	protected Link<T> _removeLink(String relation,String inverse, GraphNode<T> node) {
+		for (int i = 0; i < nodes.size(); i++) {
+			Link<T> link = nodes.get(i);
+			if (node.equals(link.to()) && equals(relation,link.getName()) && equals(inverse,link.getInverseName())) {
+				return nodes.remove(i);
+			}
+		}
+		return null;
+	}
+	
+	protected Link<T> _removeLink(String relation) {
+		for (int i = 0; i < nodes.size(); i++) {
+			Link<T> link = nodes.get(i);
+			if (equals(relation,link.getName())) {
+				return nodes.remove(i);
+			}
+		}
+		return null;
+	}
+	
+	protected Link<T> _removeLink(String relation, String inverse) {
+		for (int i = 0; i < nodes.size(); i++) {
+			Link<T> link = nodes.get(i);
+			if (equals(relation,link.getName()) && equals(inverse,link.getInverseName())) {
+				return nodes.remove(i);
+			}
+		}
+		return null;
+	}
+	
+	protected Link<T> _removeLink(String relation, GraphNode<T> node) {
+		for (int i = 0; i < nodes.size(); i++) {
+			Link<T> link = nodes.get(i);
+			if (node.equals(link.to()) && equals(relation,link.getName())) {
+				return nodes.remove(i);
+			}
+		}
+		return null;
+	}
+	
+	protected Link<T> _removeLink(GraphNode<T> node) {
+		for (int i = 0; i < nodes.size(); i++ ) {
+			Link<T> link = nodes.get(i);
+			if (node.equals(link.to())) {
+				return nodes.remove(i);
+			}
+		}
+		return null;
+	}
+	
+	protected boolean _removeLink(Link<T> link) {
+		return nodes.remove(link);
+	}
+	
+	/**
+	 * Removes the given link.
+	 * @param link
+	 * @return true if the link was removed.
+	 */
+	public boolean removeLink(Link<T> link) {
+		_checkDisposed();
+		if (_removeLink(link)) {
+			if (link.hasInverse()) {
+				link.to()._removeLink(link.getInverse());
+			}
+			return true;
+		}
+		return false;
+	}
+	
+	/**
+	 * Removes a link (or multiple links).
+	 * @param relation the name of the link from this node.
+	 * @return true if a link was removed.
+	 */
+	public boolean removeLink(String relation) {
+		_checkDisposed();
+		boolean deleted = false;
+		while (true) {
+			Link<T> removed = _removeLink(relation);
+			if (removed == null)
+				break;
+			if (removed.hasInverse()) {
+				removed.to()._removeLink(removed.getInverse());
+				deleted = true;
+			}
+		}
+		return deleted;
+	}
+	
+	/**
+	 * Removes a link (or multiple links).
+	 * @param relation the name of the link from this node.
+	 * @return true if the link was removed.
+	 */
+	public boolean removeLink(String relation, String inverse) {
+		_checkDisposed();
+		boolean deleted = false;
+		while (true) {
+			Link<T> removed = _removeLink(relation, inverse);
+			if (removed == null)
+				break;
+			if (removed.hasInverse()) {
+				removed.to()._removeLink(removed.getInverse());
+				deleted = true;
+			}
+		}
+		return deleted;
+	}
+
+	/**
+	 * Removes a link.
+	 * @param relation the name of the link from this node to the other node.
+	 * @param node the other node.
+	 * @return true if the link was removed.
+	 */
+	public boolean removeLink(String relation, GraphNode<T> node) {
+		_checkDisposed();
+		
+		boolean deleted = false;
+		while (true) {
+			Link<T> removed = _removeLink(relation, node);
+			if (removed == null)
+				break;
+			if (removed.hasInverse()) {
+				removed.to()._removeLink(removed.getInverse());
+				deleted = true;
+			}
+		}
+		return deleted;
+	}
+	
+	/**
+	 * Removes all links from this node to the other node.
+	 * @param node the other node.
+	 * @return
+	 */
+	public boolean removeLink(GraphNode<T> node) {
+		_checkDisposed();
+		boolean deleted = false;
+		while (true) {
+			Link<T> removed = _removeLink(node);
+			if (removed == null)
+				break;
+			if (removed.hasInverse()) {
+				removed.to()._removeLink(removed.getInverse());
+				deleted = true;
+			}
+		}
+		return deleted;
+	}
+	
+	/**
+	 * Removes a link.
+	 * @param relation the name of the link from this node to the other node.
+	 * @param inverse the name of the link from the other node to this node.
+	 * @param node the other node.
+	 * @return true if the link was removed.
+	 */
+	public boolean removeLink(String relation, String inverse, GraphNode<T> node) {
+		_checkDisposed();
+		Link<T> removed = _removeLink(relation, inverse, node);
+		if (removed != null && removed.hasInverse()) {
+			removed.to()._removeLink(removed.getInverse());
+			return true;
+		}
+		return false;
+	}
+	
+	public boolean containsLink(GraphNode<T> node) {
+		_checkDisposed();
+		for (Link<T> link : nodes) {
+			if (node.equals(link.to()))
+				return true;
+		}
+		return false;
+	}
+	
+	public boolean containsLink(String relationName, GraphNode<T> node) {
+		_checkDisposed();
+		if (relationName == null)
+			return false;
+		for (Link<T> link : nodes) {
+			if (node.equals(link.to()) && equals(relationName,link.getName()))
+				return true;
+		}
+		return false;
+	}
+	
+	public boolean containsLink(String relationName, String inverseName, GraphNode<T> node) {
+		_checkDisposed();
+		for (Link<T> link : nodes) {
+			if (node.equals(link.to()) && equals(relationName,link.getName()) && equals(inverseName,link.getInverseName()))
+				return true;
+		}
+		return false;
+	}
+
+	public Collection<Link<T>> getLinks() {
+		_checkDisposed();
+		Collection<Link<T>> coll = new ArrayList<Link<T>>(nodes);
+		return coll;
+	}
+	
+	public Collection<GraphNode<T>> getNodes(String rel) {
+		_checkDisposed();
+		Collection<GraphNode<T>> result = new ArrayList<GraphNode<T>>();
+
+		for (Link<T> link : nodes) {
+			if (equals(rel,link.getName()))
+				result.add(link.to());
+		}
+		
+		return result;
+	}
+	
+	public Collection<Link<T>> getLinks(String rel) {
+		_checkDisposed();
+		Collection<Link<T>> result = new ArrayList<Link<T>>();
+
+		for (Link<T> link : nodes) {
+			if (equals(rel,link.getName()))
+				result.add(link);
+		}
+		
+		return result;
+	}
+	
+	public Collection<Link<T>> getLinks(String rel, GraphNode<T> node) {
+		_checkDisposed();
+		Collection<Link<T>> result = new ArrayList<Link<T>>();
+
+		for (Link<T> link : nodes) {
+			if (equals(rel,link.getName()) && link.to().equals(node))
+				result.add(link);
+		}
+		
+		return result;
+	}
+	
+	public Collection<Link<T>> getLinks(String rel, String inverse) {
+		_checkDisposed();
+		Collection<Link<T>> result = new ArrayList<Link<T>>();
+
+		for (Link<T> link : nodes) {
+			if (equals(rel,link.getName()) && equals(inverse, link.getInverseName()))
+				result.add(link);
+		}
+		
+		return result;
+	}
+	
+	public Collection<Link<T>> getLinks(String rel, String inverse, GraphNode<T> node) {
+		_checkDisposed();
+		Collection<Link<T>> result = new ArrayList<Link<T>>();
+
+		for (Link<T> link : nodes) {
+			if (equals(rel,link.getName()) && equals(inverse, link.getInverseName()) && link.to().equals(node))
+				result.add(link);
+		}
+		
+		return result;
+	}
+	
+	public Collection<GraphNode<T>> getNodesWithInv(String inv) {
+		_checkDisposed();
+		Collection<GraphNode<T>> result = new ArrayList<GraphNode<T>>();
+
+		for (Link<T> link : nodes) {
+			if (equals(inv,link.getInverseName()))
+				result.add(link.to());
+		}
+		
+		return result;
+	}
+	
+	public Collection<GraphNode<T>> getNodes(String rel, String inv) {
+		_checkDisposed();
+		Collection<GraphNode<T>> result = new ArrayList<GraphNode<T>>();
+
+		for (Link<T> link : nodes) {
+			if (equals(rel,link.getName()) && equals(inv,link.getInverseName()))
+				result.add(link.to());
+		}
+
+		return result;
+	}
+	
+	public static boolean equals(String s1, String s2) {
+		if (s1 != null)
+			return s1.equals(s2);
+		if (s2 != null)
+			return s2.equals(s1);
+		return true; // both null
+	}
+	
+	
+	/**
+	 * Returns links from this node to the given node.
+	 * @param node
+	 * @return
+	 */
+	public Collection<Link<T>> getLinks(GraphNode<T> node) {
+		_checkDisposed();
+		Collection<Link<T>> result = new ArrayList<Link<T>>();
+		for (Link<T> link : nodes) {
+			if (link.to().equals(node))
+				result.add(link);
+		}
+		return result;
+	}
+	
+	/**
+	 * Returns names of links from this node to the given node. Does not return null names.
+	 * @param node
+	 * @return
+	 */
+	public Collection<String> getRelations(GraphNode<T> node) {
+		_checkDisposed();
+		Collection<String> result = new ArrayList<String>();
+		for (Link<T> link : nodes) {
+			if (link.to().equals(node) && link.getName() != null)
+				result.add(link.getName());
+		}
+		return result;
+	}
+	
+	/**
+	 * Returns links from given node to this node.
+	 * @param node
+	 * @return
+	 */
+	public Collection<Link<T>> getInverseLinks(GraphNode<T> node) {
+		_checkDisposed();
+		Collection<Link<T>> result = new ArrayList<Link<T>>();
+		for (Link<T> link : nodes) {
+			if (link.to().equals(node))
+				result.add(link.getInverse());
+		}
+		return result;
+	}
+	
+	/**
+	 * Returns names of links from given node to this node. Does not return null names.
+	 * @param node
+	 * @return
+	 */
+	public Collection<String> getInverses(GraphNode<T> node) {
+		_checkDisposed();
+		Collection<String> result = new ArrayList<String>();
+		for (Link<T> link : nodes) {
+			if (link.to().equals(node) && link.getInverseName() != null)
+				result.add(link.getInverseName());
+		}
+		return result;
+	}
+	
+	
+	
+	@Override
+	public int hashCode() {
+		return data.hashCode();
+	}
+	
+	@Override
+	public boolean equals(Object arg0) {
+		if (!arg0.getClass().equals(getClass()))
+			return false;
+		GraphNode<?> other = (GraphNode<?>)arg0;
+		if (this == other)
+			return true;
+		if (this.data == null || other.data == null)
+			return false;
+		if (!data.equals(other.data))
+			return false;
+
+		return true;
+	}
+	
+	/**
+	 * Merges given nodes to new node. 
+	 * Does not copy hints!
+	 * @param other
+	 */
+	public GraphNode<T> merge(GraphNode<T> other, T mergedData) {
+		_checkDisposed();
+		GraphNode<T> mergedNode = new GraphNode<T>(mergedData);
+		copyLinks(this, mergedNode);
+		copyLinks(other, mergedNode);
+		
+		//mergedNode.setHints(other.getHints());
+		//mergedNode.setHints(this.getHints());
+		
+		this.destroy();
+		other.destroy();
+		
+		return mergedNode;
+	}
+	
+	
+	
+	
+	
+	/**
+	 * Copies a link to other node.
+	 * @param from the node containing original link
+	 * @param to the node where link is copied to
+	 * @param l the link that is copied.
+	 * @return created link, if copy is successful. Otherwise returns null.
+	 */
+	public static <T> Link<T> copyLink(GraphNode<T> from, GraphNode<T> to, Link<T> l) {
+		if (l.from() != from)
+			throw new IllegalArgumentException("Link is not starting from " + from + " node.");
+		if (l.to() == to)
+			return null;
+		if (to.containsLink(l.getName(), l.getInverseName(),l.to()))
+			return null;
+		if (l.isMain()) {
+			Link<T> newLink = to.addLink(l.getName(),l.getInverseName(),l.to());
+			if (newLink != null) {
+				newLink.setHints(l.getHints());
+				newLink.getInverse().setHints(l.getInverse().getHints());
+				return newLink;
+			} else {
+				return null;
+			}
+		} else {
+			Link<T> newLink = l.to().addLink(l.getInverseName(), l.getName(),to);
+			if (newLink != null) {
+				newLink.setHints(l.getInverse().getHints());
+				newLink.getInverse().setHints(l.getHints());
+				return newLink.getInverse();
+			} else {
+				return null;
+			}
+		}	
+		
+	}
+	
+	/**
+	 * Copies a link to other node, but inverts its direction.
+	 * @param from the node containing original link
+	 * @param to the node where link is copied to
+	 * @param l the link that is copied.
+	 * @return created link, if copy is successful. Otherwise returns null.
+	 */
+	public static <T> Link<T> copyLinkInverse(GraphNode<T> from, GraphNode<T> to, Link<T> l) {
+		if (l.from() != from)
+			throw new IllegalArgumentException("Link is not starting from " + from + " node.");
+		if (l.to() == to)
+			return null;
+		if (to.containsLink(l.getInverseName(), l.getName(),l.to()))
+			return null;
+		if (l.isMain()) {
+			Link<T> newLink = l.to().addLink(l.getName(),l.getInverseName(),to);
+			if (newLink != null) {
+				newLink.setHints(l.getHints());
+				newLink.getInverse().setHints(l.getInverse().getHints());
+				return newLink;
+			} else {
+				return null;
+			}
+		} else {
+			Link<T> newLink = to.addLink(l.getInverseName(), l.getName(),l.to());
+			if (newLink != null) {
+				newLink.setHints(l.getInverse().getHints());
+				newLink.getInverse().setHints(l.getHints());
+				return newLink.getInverse();
+			} else {
+				return null;
+			}
+		}	
+		
+	}
+
+	public static <T> void copyLinks(GraphNode<T> from, GraphNode<T> to, Collection<Link<T>> links) {
+		for (Link<T> l : links) {
+			copyLink(from, to, l);
+		}
+	}
+
+	
+	public static <T> void copyLinks(GraphNode<T> from, GraphNode<T> to) {
+		for (Link<T> l : from.getLinks()) {
+			copyLink(from, to, l);
+		}
+	}
+	
+	/**
+	 * Copies a link to other node and removes the original link. If move is not successful, the original link is not removed.
+	 * @param from the node containing original link
+	 * @param to the node where link is copied to
+	 * @param l the link that is moved.
+	 * @return created link, if move is successful. Otherwise returns null. 
+	 */
+	public static <T> Link<T> moveLink(GraphNode<T> from, GraphNode<T> to, Link<T> l) {
+		Link<T> newLink = copyLink(from, to, l);
+		if (newLink != null) {
+			from.removeLink(l);
+			return newLink;
+		}
+		return null;
+	}
+	
+	public static <T> void moveLinks(GraphNode<T> from, GraphNode<T> to, Collection<Link<T>> links) {
+		for (Link<T> l : links) {
+			Link<T> newLink = copyLink(from, to, l);
+			if (newLink != null) {
+				from.removeLink(l);
+			}	
+		}
+	}
+	
+	public static <T> void moveLinkInverses(GraphNode<T> from, GraphNode<T> to, Collection<Link<T>> links) {
+		for (Link<T> l : links) {
+			Link<T> newLink = copyLinkInverse(from, to, l);
+			if (newLink != null) {
+				from.removeLink(l);
+			}	
+		}
+	}
+	
+	public static <T> void moveLinks(GraphNode<T> from, GraphNode<T> to) {
+		for (Link<T> l : from.getLinks()) {
+			Link<T> newLink = copyLink(from, to, l);
+			if (newLink != null) {
+				from.removeLink(l);
+			}	
+		}
+	}
+	
+	/**
+	 * Replaces a link with a link going first to given node, and the to the original destination.
+	 * The link names and hints are copied to the created links.
+	 * 
+	 * Example: link is 'a' -> 'b'. With insert attribute 'c', the result is 'a' -> 'c' -> 'b'.
+	 *   
+	 * @param link
+	 * @param insert
+	 * @return Array containing created links (2).
+	 */
+	@SuppressWarnings("unchecked")
+	public static <T> Link<T>[] insert(Link<T> link, GraphNode<T> insert) {
+		GraphNode<T> a = link.from();
+		Link<T> c_b = moveLink(a, insert, link);
+		Link<T> a_c = a.addLink(c_b, insert);
+		return new Link[]{a_c,c_b};
+	}
+
+	
+	
+	/**
+	 * Finds all nodes that have the same relations to the same nodes as this node. 
+	 * @return
+	 */
+	public Collection<GraphNode<T>> getFullSimilars() {
+		_checkDisposed();
+		Collection<GraphNode<T>> result = new ArrayList<GraphNode<T>>();
+		Set<GraphNode<T>> potential = new HashSet<GraphNode<T>>();
+		for (Link<T> link : nodes) {
+			for (Link<T> link2 : link.to().nodes) {
+				if (!link2.to().equals(this))
+					potential.add(link2.to());
+			}
+		}
+		for (GraphNode<T> node : potential) {
+			if (node.nodes.containsAll(nodes))
+				result.add(node);
+		}
+		
+		return result;
+	}
+	
+	/**
+	 * Finds all nodes that have at least one similar relation to the same nodes as this node. 
+	 * @return
+	 */
+	public Collection<GraphNode<T>> getSemiSimilars() {
+		_checkDisposed();
+		Collection<GraphNode<T>> result = new ArrayList<GraphNode<T>>();
+		Set<GraphNode<T>> potential = new HashSet<GraphNode<T>>();
+		for (Link<T> link : nodes) {
+			for (Link<T> link2 : link.to().nodes) {
+				if (!link2.to().equals(this))
+					potential.add(link2.to());
+			}
+		}
+		for (GraphNode<T> node : potential) {
+			for (Link<T> link : nodes) {
+				if (node.nodes.contains(link))
+					result.add(node);
+			}
+		}
+		
+		return result;
+	}
+	
+
+	/**
+	 * Disposes this node. Removes all the links that connect to thi snode.
+	 */
+	public void destroy() {
+		if (disposed)
+			return;
+		Logger.defaultLogInfo("Node destroy " + data + " " + this);
+		Collection<Link<T>> coll = new ArrayList<Link<T>>();
+		coll.addAll(nodes);
+		nodes.clear();
+		for (Link<T> link : coll) {
+			link.to()._removeLink(this);
+		}
+		nodes = null;
+		disposed = true;
+	}
+	
+	/**
+	 * Removes this node from the graph, and reconnects parents and children of this node.
+	 */
+	public void remove() {
+		if (disposed)
+			return;
+		// FIXME: link.to may be *this.
+		Logger.defaultLogInfo("Node remove " + data + " " + this);
+		if (nodes.size() == 1) {
+			Link<T> link = nodes.get(0);
+			link.to().removeLink(link.getInverseName(), link.getName(), this);
+		} else {
+			for (int i = 0; i < nodes.size() -1 ; i++) {
+				Link<T> link1 = nodes.get(i);
+				link1.to().removeLink(link1.getInverseName(), link1.getName(), this);
+				for (int j = i; j < nodes.size(); j++) {
+					Link<T> link2 = nodes.get(j);
+					link2.to().removeLink(link2.getInverseName(), link2.getName(), this);
+					if (link1.to().equals(link2.to()))
+						continue;
+					link1.to().addLink(link1.getInverseName(),link2.getInverseName(),link2.to());
+				}
+				
+			}
+		}
+		
+		nodes.clear();
+		nodes = null;
+		disposed = true;
+
+	}
+	
+	/**
+	 * 
+	 * @return true if the node has been disposed and cannot be used anymore.
+	 */
+	public boolean isDisposed() {
+		return disposed;
+	}
+	
+	/**
+	 * Disposed the node and all nodes that are in the same graph.
+	 */
+	public void dispose() {
+		if (disposed)
+			return;
+		Collection<Link<T>> links = new ArrayList<Link<T>>();
+		links.addAll(nodes);
+		nodes.clear();
+		for (Link<T> l : links)
+			l.to().dispose();
+		links.clear();
+		nodes = null;
+		disposed = true;
+	}
+	
+
+	protected void _checkDisposed() {
+		if (disposed) {
+			Logger.defaultLogError("Remove Node, disposed " + this);
+			throw new RuntimeException("Node " + this + " is disposed.");
+		}
+	}
+	
+	
+	public int distanceTo(GraphNode<T> node, String rel, String inv) {
+		if (node.equals(this))
+			return 0;
+		int count = 0;
+		Set<GraphNode<T>> processed = new HashSet<GraphNode<T>>();
+		Set<GraphNode<T>> next = new HashSet<GraphNode<T>>();
+		next.add(this);
+		while (true) {
+			if (next.size() == 0)
+				return -1;
+			count++;
+			processed.addAll(next);
+			Set<GraphNode<T>> nextNext = new HashSet<GraphNode<T>>();
+			for (GraphNode<T> n : next) {
+				for (GraphNode<T> nn : n.getNodes(rel, inv))
+					if (!processed.contains(nn))
+						nextNext.add(nn);
+			}
+			next = nextNext;
+			if (next.contains(node))
+				return count;
+		}
+	}
+}