Hi Patrik, there is a lot of commits in your lab, maybe it would be cool to have a small intro on what you are doing and what the status of the algos are?
/peter On Thu, May 22, 2008 at 7:17 PM, <[EMAIL PROTECTED]> wrote: > Author: patrik > Date: 2008-05-22 19:17:29 +0200 (Thu, 22 May 2008) > New Revision: 1597 > > Log: > Various experimental subgraph implementations > > Added: > > laboratory/users/patrik/neoalgo/trunk/src/main/java/org/neo4j/algo/graphGeneration/SubNetwork.java > > laboratory/users/patrik/neoalgo/trunk/src/main/java/org/neo4j/algo/graphGeneration/SubNetworkCopy.java > > Added: > laboratory/users/patrik/neoalgo/trunk/src/main/java/org/neo4j/algo/graphGeneration/SubNetwork.java > =================================================================== > --- > laboratory/users/patrik/neoalgo/trunk/src/main/java/org/neo4j/algo/graphGeneration/SubNetwork.java > (rev 0) > +++ > laboratory/users/patrik/neoalgo/trunk/src/main/java/org/neo4j/algo/graphGeneration/SubNetwork.java > 2008-05-22 17:17:29 UTC (rev 1597) > @@ -0,0 +1,603 @@ > +package org.neo4j.algo.graphGeneration; > + > +import java.util.HashMap; > +import java.util.HashSet; > +import java.util.LinkedList; > +import java.util.List; > +import java.util.Map; > +import java.util.Set; > +import org.neo4j.api.core.Direction; > +import org.neo4j.api.core.Node; > +import org.neo4j.api.core.Relationship; > +import org.neo4j.api.core.RelationshipType; > +import org.neo4j.api.core.ReturnableEvaluator; > +import org.neo4j.api.core.StopEvaluator; > +import org.neo4j.api.core.TraversalPosition; > +import org.neo4j.api.core.Traverser; > +import org.neo4j.api.core.Traverser.Order; > +import org.neo4j.impl.traversal.TraverserFactory; > + > +/** > + * This class can be used to represent part of a network (like a subgraph), > + * represented as a set of nodes and a set of edges. All this really does is > + * filter the results of Node.getRelationships to only return relationships > + * within this subnetwork, thus limiting traversals and searches to the nodes > + * within the subnetwork. Therefore, any changes made to the subnetwork will > be > + * reflected in the underlying network as well. The subgraph always starts > out > + * empty, and can be emptied again with the clear() method. It can then be > + * filled with nodes and edges through the various methods supplied. This > class > + * can of course also be used to retrieve the set of all nodes and the set of > + * all edges from a network. > + * @author Patrik Larsson > + */ > +public class SubNetwork > +{ > + Set<Relationship> subNetworkRelationships = new HashSet<Relationship>(); > + Set<Node> subNetworkNodes = new HashSet<Node>(); > + TraverserFactory traverserFactory = new TraverserFactory(); > + > + /** > + * Adds a tree to this subnetwork by doing a breadth first search of a > given > + * depth, adding all nodes found and the first edge leading to each node. > + * @param node > + * The starting node > + * @param searchDepth > + * The search depth. > + * @param relationshipType > + * Relation type to traverse. > + * @param direction > + * Direction in which to traverse relationships. > + */ > + public void addTreeFromCentralNode( Node node, final int searchDepth, > + RelationshipType relationshipType, Direction direction ) > + { > + Traverser traverser = node.traverse( Order.BREADTH_FIRST, > + new StopEvaluator() > + { > + public boolean isStopNode( TraversalPosition currentPos ) > + { > + return currentPos.depth() >= searchDepth; > + } > + }, ReturnableEvaluator.ALL, relationshipType, direction ); > + for ( Node node2 : traverser ) > + { > + subNetworkNodes.add( node2 ); > + subNetworkRelationships.add( traverser.currentPosition() > + .lastRelationshipTraversed() ); > + } > + } > + > + /** > + * Makes a search of a given depth from a given node and adds all found > + * nodes and relationships to this subnetwork. > + * @param node > + * The starting node > + * @param searchDepth > + * The search depth. > + * @param relationshipType > + * Relation type to traverse. > + * @param direction > + * Direction in which to traverse relationships. > + * @param includeBoundaryRelationships > + * If false, relationships between nodes where the maximum > depth > + * has been reached will not be included since the search > depth > + * is considered to have been exhausted at them. > + */ > + public void addSubNetworkFromCentralNode( Node node, final int > searchDepth, > + RelationshipType relationshipType, Direction direction, > + boolean includeBoundaryRelationships ) > + { > + internalAddSubNetworkFromCentralNode( node, searchDepth, > + relationshipType, direction, includeBoundaryRelationships, > + new HashMap<Node,Integer>() ); > + } > + > + /** > + * Same as addSubNetworkFromCentralNode, but the internal version with > some > + * extra data sent along. > + * @param nodeScanDepths > + * This stores at what depth a certain node was added so we > can > + * ignore it when we reach it with a lower depth. > + */ > + protected void internalAddSubNetworkFromCentralNode( Node node, > + final int searchDepth, RelationshipType relationshipType, > + Direction direction, boolean includeBoundaryRelationships, > + Map<Node,Integer> nodeScanDepths ) > + { > + // We stop here if this node has already been scanned and we this > time > + // have a "shorter" way to go beyond it. > + Integer previousDepth = nodeScanDepths.get( node ); > + if ( previousDepth != null && previousDepth >= searchDepth ) > + { > + return; > + } > + subNetworkNodes.add( node ); > + nodeScanDepths.put( node, searchDepth ); > + if ( searchDepth == 0 && includeBoundaryRelationships ) > + { > + for ( Relationship relationship : node.getRelationships( > + relationshipType, direction ) ) > + { > + if ( subNetworkNodes > + .contains( relationship.getOtherNode( node ) ) ) > + { > + subNetworkRelationships.add( relationship ); > + } > + } > + } > + if ( searchDepth <= 0 ) > + { > + return; > + } > + for ( Relationship relationship : node.getRelationships( > + relationshipType, direction ) ) > + { > + subNetworkRelationships.add( relationship ); > + internalAddSubNetworkFromCentralNode( relationship > + .getOtherNode( node ), searchDepth - 1, relationshipType, > + direction, includeBoundaryRelationships, nodeScanDepths ); > + } > + } > + > + public void clear() > + { > + subNetworkRelationships = new HashSet<Relationship>(); > + subNetworkNodes = new HashSet<Node>(); > + } > + > + protected Relationship filterRelationship( Relationship relationship ) > + { > + if ( subNetworkRelationships.contains( relationship ) ) > + { > + return relationship; > + } > + return null; > + } > + > + protected Iterable<Relationship> filterRelationships( > + Iterable<Relationship> rels ) > + { > + List<Relationship> result = new LinkedList<Relationship>(); > + for ( Relationship relationship : rels ) > + { > + if ( filterRelationship( relationship ) != null ) > + { > + result.add( relationship ); > + } > + } > + return result; > + } > + > + class SubNetWorkNode implements Node > + { > + Node underlyingNode; > + > + public SubNetWorkNode( Node underlyingNode ) > + { > + super(); > + this.underlyingNode = underlyingNode; > + } > + > + /** > + * @param otherNode > + * @param type > + * @return > + * @see > org.neo4j.api.core.Node#createRelationshipTo(org.neo4j.api.core.Node, > + * org.neo4j.api.core.RelationshipType) > + */ > + public Relationship createRelationshipTo( Node otherNode, > + RelationshipType type ) > + { > + return new SubNetworkRelationship( underlyingNode > + .createRelationshipTo( otherNode, type ) ); > + } > + > + /** > + * @see org.neo4j.api.core.Node#delete() > + */ > + public void delete() > + { > + underlyingNode.delete(); > + } > + > + /** > + * @return > + * @see org.neo4j.api.core.Node#getId() > + */ > + public long getId() > + { > + return underlyingNode.getId(); > + } > + > + /** > + * @param arg0 > + * @param arg1 > + * @return > + * @see > org.neo4j.api.core.PropertyContainer#getProperty(java.lang.String, > + * java.lang.Object) > + */ > + public Object getProperty( String arg0, Object arg1 ) > + { > + return underlyingNode.getProperty( arg0, arg1 ); > + } > + > + /** > + * @param arg0 > + * @return > + * @see > org.neo4j.api.core.PropertyContainer#getProperty(java.lang.String) > + */ > + public Object getProperty( String arg0 ) > + { > + return underlyingNode.getProperty( arg0 ); > + } > + > + /** > + * @return > + * @see org.neo4j.api.core.PropertyContainer#getPropertyKeys() > + */ > + public Iterable<String> getPropertyKeys() > + { > + return underlyingNode.getPropertyKeys(); > + } > + > + /** > + * @return > + * @see org.neo4j.api.core.PropertyContainer#getPropertyValues() > + */ > + public Iterable<Object> getPropertyValues() > + { > + return underlyingNode.getPropertyValues(); > + } > + > + /** > + * @return > + * @see org.neo4j.api.core.Node#getRelationships() > + */ > + public Iterable<Relationship> getRelationships() > + { > + return filterRelationships( underlyingNode.getRelationships() ); > + } > + > + /** > + * @param dir > + * @return > + * @see > org.neo4j.api.core.Node#getRelationships(org.neo4j.api.core.Direction) > + */ > + public Iterable<Relationship> getRelationships( Direction dir ) > + { > + return filterRelationships( underlyingNode.getRelationships( dir > ) ); > + } > + > + /** > + * @param type > + * @param dir > + * @return > + * @see > org.neo4j.api.core.Node#getRelationships(org.neo4j.api.core.RelationshipType, > + * org.neo4j.api.core.Direction) > + */ > + public Iterable<Relationship> getRelationships( RelationshipType > type, > + Direction dir ) > + { > + return filterRelationships( underlyingNode.getRelationships( > type, > + dir ) ); > + } > + > + /** > + * @param types > + * @return > + * @see > org.neo4j.api.core.Node#getRelationships(org.neo4j.api.core.RelationshipType[]) > + */ > + public Iterable<Relationship> getRelationships( > + RelationshipType... types ) > + { > + return filterRelationships( underlyingNode.getRelationships( > types ) ); > + } > + > + /** > + * @param type > + * @param dir > + * @return > + * @see > org.neo4j.api.core.Node#getSingleRelationship(org.neo4j.api.core.RelationshipType, > + * org.neo4j.api.core.Direction) > + */ > + public Relationship getSingleRelationship( RelationshipType type, > + Direction dir ) > + { > + return filterRelationship( underlyingNode.getSingleRelationship( > + type, dir ) ); > + } > + > + /** > + * @param arg0 > + * @return > + * @see > org.neo4j.api.core.PropertyContainer#hasProperty(java.lang.String) > + */ > + public boolean hasProperty( String arg0 ) > + { > + return underlyingNode.hasProperty( arg0 ); > + } > + > + public boolean hasRelationship() > + { > + return getRelationships().iterator().hasNext(); > + } > + > + public boolean hasRelationship( RelationshipType... types ) > + { > + return getRelationships( types ).iterator().hasNext(); > + } > + > + public boolean hasRelationship( Direction dir ) > + { > + return getRelationships( dir ).iterator().hasNext(); > + } > + > + public boolean hasRelationship( RelationshipType type, Direction dir > ) > + { > + return getRelationships( type, dir ).iterator().hasNext(); > + } > + > + /** > + * @param arg0 > + * @return > + * @see > org.neo4j.api.core.PropertyContainer#removeProperty(java.lang.String) > + */ > + public Object removeProperty( String arg0 ) > + { > + return underlyingNode.removeProperty( arg0 ); > + } > + > + /** > + * @param arg0 > + * @param arg1 > + * @see > org.neo4j.api.core.PropertyContainer#setProperty(java.lang.String, > + * java.lang.Object) > + */ > + public void setProperty( String arg0, Object arg1 ) > + { > + underlyingNode.setProperty( arg0, arg1 ); > + } > + > + public Traverser traverse( Order traversalOrder, > + StopEvaluator stopEvaluator, > + ReturnableEvaluator returnableEvaluator, > + RelationshipType relationshipType, Direction direction ) > + { > + if ( direction == null ) > + { > + throw new IllegalArgumentException( "Null direction" ); > + } > + if ( relationshipType == null ) > + { > + throw new IllegalArgumentException( "Null relationship type" > ); > + } > + // rest of parameters will be validated in traverser package > + return traverserFactory > + .createTraverser( traversalOrder, this, relationshipType, > + direction, stopEvaluator, returnableEvaluator ); > + } > + > + public Traverser traverse( Order traversalOrder, > + StopEvaluator stopEvaluator, > + ReturnableEvaluator returnableEvaluator, > + RelationshipType firstRelationshipType, Direction firstDirection, > + RelationshipType secondRelationshipType, Direction > secondDirection ) > + { > + if ( firstDirection == null || secondDirection == null ) > + { > + throw new IllegalArgumentException( "Null direction, " > + + "firstDirection=" + firstDirection + "secondDirection=" > + + secondDirection ); > + } > + if ( firstRelationshipType == null > + || secondRelationshipType == null ) > + { > + throw new IllegalArgumentException( "Null rel type, " > + + "first=" + firstRelationshipType + "second=" > + + secondRelationshipType ); > + } > + // rest of parameters will be validated in traverser package > + RelationshipType[] types = new RelationshipType[2]; > + Direction[] dirs = new Direction[2]; > + types[0] = firstRelationshipType; > + types[1] = secondRelationshipType; > + dirs[0] = firstDirection; > + dirs[1] = secondDirection; > + return traverserFactory.createTraverser( traversalOrder, this, > + types, dirs, stopEvaluator, returnableEvaluator ); > + } > + > + public Traverser traverse( Order traversalOrder, > + StopEvaluator stopEvaluator, > + ReturnableEvaluator returnableEvaluator, > + Object... relationshipTypesAndDirections ) > + { > + int length = relationshipTypesAndDirections.length; > + if ( (length % 2) != 0 || length == 0 ) > + { > + throw new IllegalArgumentException( "Variable argument > should " > + + " consist of [RelationshipType,Direction] pairs" ); > + } > + int elements = relationshipTypesAndDirections.length / 2; > + RelationshipType[] types = new RelationshipType[elements]; > + Direction[] dirs = new Direction[elements]; > + int j = 0; > + for ( int i = 0; i < elements; i++ ) > + { > + Object relType = relationshipTypesAndDirections[j++]; > + if ( !(relType instanceof RelationshipType) ) > + { > + throw new IllegalArgumentException( > + "Expected RelationshipType at var args pos " + (j - > 1) > + + ", found " + relType ); > + } > + types[i] = (RelationshipType) relType; > + Object direction = relationshipTypesAndDirections[j++]; > + if ( !(direction instanceof Direction) ) > + { > + throw new IllegalArgumentException( > + "Expected Direction at var args pos " + (j - 1) > + + ", found " + direction ); > + } > + dirs[i] = (Direction) direction; > + } > + return traverserFactory.createTraverser( traversalOrder, this, > + types, dirs, stopEvaluator, returnableEvaluator ); > + } > + } > + public class SubNetworkRelationship implements Relationship > + { > + Relationship underlyingRelationship; > + > + public SubNetworkRelationship( Relationship underlyingRelationship ) > + { > + super(); > + this.underlyingRelationship = underlyingRelationship; > + } > + > + /** > + * @see org.neo4j.api.core.Relationship#delete() > + */ > + public void delete() > + { > + underlyingRelationship.delete(); > + } > + > + /** > + * @return > + * @see org.neo4j.api.core.Relationship#getEndNode() > + */ > + public Node getEndNode() > + { > + return new SubNetWorkNode( underlyingRelationship.getEndNode() ); > + } > + > + /** > + * @return > + * @see org.neo4j.api.core.Relationship#getId() > + */ > + public long getId() > + { > + return underlyingRelationship.getId(); > + } > + > + /** > + * @return > + * @see org.neo4j.api.core.Relationship#getNodes() > + */ > + public Node[] getNodes() > + { > + return new Node[] { getStartNode(), getEndNode() }; > + } > + > + /** > + * @param node > + * @return > + * @see > org.neo4j.api.core.Relationship#getOtherNode(org.neo4j.api.core.Node) > + */ > + public Node getOtherNode( Node node ) > + { > + return new SubNetWorkNode( underlyingRelationship > + .getOtherNode( node ) ); > + } > + > + /** > + * @param arg0 > + * @param arg1 > + * @return > + * @see > org.neo4j.api.core.PropertyContainer#getProperty(java.lang.String, > + * java.lang.Object) > + */ > + public Object getProperty( String arg0, Object arg1 ) > + { > + return underlyingRelationship.getProperty( arg0, arg1 ); > + } > + > + /** > + * @param arg0 > + * @return > + * @see > org.neo4j.api.core.PropertyContainer#getProperty(java.lang.String) > + */ > + public Object getProperty( String arg0 ) > + { > + return underlyingRelationship.getProperty( arg0 ); > + } > + > + /** > + * @return > + * @see org.neo4j.api.core.PropertyContainer#getPropertyKeys() > + */ > + public Iterable<String> getPropertyKeys() > + { > + return underlyingRelationship.getPropertyKeys(); > + } > + > + /** > + * @return > + * @see org.neo4j.api.core.PropertyContainer#getPropertyValues() > + */ > + public Iterable<Object> getPropertyValues() > + { > + return underlyingRelationship.getPropertyValues(); > + } > + > + /** > + * @return > + * @see org.neo4j.api.core.Relationship#getStartNode() > + */ > + public Node getStartNode() > + { > + return new SubNetWorkNode( underlyingRelationship.getStartNode() > ); > + } > + > + /** > + * @return > + * @see org.neo4j.api.core.Relationship#getType() > + */ > + public RelationshipType getType() > + { > + return underlyingRelationship.getType(); > + } > + > + /** > + * @param arg0 > + * @return > + * @see > org.neo4j.api.core.PropertyContainer#hasProperty(java.lang.String) > + */ > + public boolean hasProperty( String arg0 ) > + { > + return underlyingRelationship.hasProperty( arg0 ); > + } > + > + /** > + * @param type > + * @return > + * @see > org.neo4j.api.core.Relationship#isType(org.neo4j.api.core.RelationshipType) > + */ > + public boolean isType( RelationshipType type ) > + { > + return underlyingRelationship.isType( type ); > + } > + > + /** > + * @param arg0 > + * @return > + * @see > org.neo4j.api.core.PropertyContainer#removeProperty(java.lang.String) > + */ > + public Object removeProperty( String arg0 ) > + { > + return underlyingRelationship.removeProperty( arg0 ); > + } > + > + /** > + * @param arg0 > + * @param arg1 > + * @see > org.neo4j.api.core.PropertyContainer#setProperty(java.lang.String, > + * java.lang.Object) > + */ > + public void setProperty( String arg0, Object arg1 ) > + { > + underlyingRelationship.setProperty( arg0, arg1 ); > + } > + } > +} > > Added: > laboratory/users/patrik/neoalgo/trunk/src/main/java/org/neo4j/algo/graphGeneration/SubNetworkCopy.java > =================================================================== > --- > laboratory/users/patrik/neoalgo/trunk/src/main/java/org/neo4j/algo/graphGeneration/SubNetworkCopy.java > (rev 0) > +++ > laboratory/users/patrik/neoalgo/trunk/src/main/java/org/neo4j/algo/graphGeneration/SubNetworkCopy.java > 2008-05-22 17:17:29 UTC (rev 1597) > @@ -0,0 +1,633 @@ > +package org.neo4j.algo.graphGeneration; > + > +import java.util.HashMap; > +import java.util.HashSet; > +import java.util.LinkedList; > +import java.util.List; > +import java.util.Map; > +import java.util.Set; > +import org.neo4j.api.core.Direction; > +import org.neo4j.api.core.Node; > +import org.neo4j.api.core.Relationship; > +import org.neo4j.api.core.RelationshipType; > +import org.neo4j.api.core.ReturnableEvaluator; > +import org.neo4j.api.core.StopEvaluator; > +import org.neo4j.api.core.TraversalPosition; > +import org.neo4j.api.core.Traverser; > +import org.neo4j.api.core.Traverser.Order; > +import org.neo4j.impl.traversal.TraverserFactory; > + > +/** > + * This class can be used to generate an in-memory copy of a part of a > network > + * (like a subgraph), represented as a set of copys of nodes and a set of > copys > + * of edges. Currently, any changes made to the subnetwork will be reflected > in > + * the underlying network as well. The subgraph always starts out empty, and > can > + * be emptied again with the clear() method. It can then be filled with nodes > + * and edges through the various methods supplied. This class can of course > be > + * used to retrieve the set of all nodes and the set of all edges from a > + * network. > + * @author Patrik Larsson > + */ > +public class SubNetworkCopy > +{ > + Set<Relationship> subNetworkRelationships = new HashSet<Relationship>(); > + Map<Node,SubNetworkNode> nodeMap = new HashMap<Node,SubNetworkNode>(); > + > + public SubNetworkRelationship addRelationship( > + Relationship underlyingRelationship ) > + { > + SubNetworkRelationship subNetworkRelationship = new > SubNetworkRelationship( > + underlyingRelationship, nodeMap.get( underlyingRelationship > + .getStartNode() ), nodeMap.get( underlyingRelationship > + .getEndNode() ) ); > + subNetworkRelationships.add( subNetworkRelationship ); > + return subNetworkRelationship; > + } > + > + /** > + * Empties this subnetwork. > + */ > + public void clear() > + { > + subNetworkRelationships = new HashSet<Relationship>(); > + nodeMap = new HashMap<Node,SubNetworkNode>(); > + } > + > + /** > + * Adds a tree to this subnetwork by doing a breadth first search of a > given > + * depth, adding all nodes found and the first edge leading to each node. > + * @param node > + * The starting node > + * @param searchDepth > + * The search depth. > + * @param relationshipType > + * Relation type to traverse. > + * @param direction > + * Direction in which to traverse edges. > + */ > + public void addTreeFromCentralNode( Node node, final int searchDepth, > + RelationshipType relationshipType, Direction direction ) > + { > + Traverser traverser = node.traverse( Order.BREADTH_FIRST, > + new StopEvaluator() > + { > + public boolean isStopNode( TraversalPosition currentPos ) > + { > + return currentPos.depth() >= searchDepth; > + } > + }, ReturnableEvaluator.ALL, relationshipType, direction ); > + for ( Node node2 : traverser ) > + { > + nodeMap.put( node2, new SubNetworkNode( node2 ) ); > + Relationship relationship = traverser.currentPosition() > + .lastRelationshipTraversed(); > + if ( relationship != null ) > + { > + addRelationship( relationship ); > + } > + } > + } > + > + /** > + * Makes a search of a given depth from a given node and adds all found > + * nodes and relationships to this subnetwork. > + * @param node > + * The starting node > + * @param searchDepth > + * The search depth. > + * @param relationshipType > + * Relation type to traverse. > + * @param direction > + * Direction in which to traverse edges. > + */ > + public void addSubNetworkFromCentralNode( Node node, final int > searchDepth, > + RelationshipType relationshipType, Direction direction ) > + { > + internalAddSubNetworkFromCentralNode( node, searchDepth, > + relationshipType, direction, new HashMap<Node,Integer>() ); > + } > + > + /** > + * Same as addSubNetworkFromCentralNode, but the internal version with > some > + * extra data sent along. > + * @param nodeScanDepths > + * This stores at what depth a certain node was added so we > can > + * ignore it when we reach it with a lower depth. > + */ > + protected void internalAddSubNetworkFromCentralNode( Node node, > + final int searchDepth, RelationshipType relationshipType, > + Direction direction, Map<Node,Integer> nodeScanDepths ) > + { > + // We stop here if this node has already been scanned and we this > time > + // have a "shorter" way to go beyond it. > + Integer previousDepth = nodeScanDepths.get( node ); > + if ( previousDepth != null && previousDepth >= searchDepth ) > + { > + return; > + } > + nodeMap.put( node, new SubNetworkNode( node ) ); > + nodeScanDepths.put( node, searchDepth ); > + for ( Relationship relationship : node.getRelationships( > + relationshipType, direction ) ) > + { > + Node otherNode = relationship.getOtherNode( node ); > + if ( nodeMap.containsKey( otherNode ) ) > + { > + addRelationship( relationship ); > + } > + } > + if ( searchDepth <= 0 ) > + { > + return; > + } > + for ( Relationship relationship : node.getRelationships( > + relationshipType, direction ) ) > + { > + internalAddSubNetworkFromCentralNode( relationship > + .getOtherNode( node ), searchDepth - 1, relationshipType, > + direction, nodeScanDepths ); > + } > + } > + > + /** > + * @return the relationships > + */ > + public Set<Relationship> getEdges() > + { > + return subNetworkRelationships; > + } > + > + /** > + * @return the nodes > + */ > + public Set<Node> getNodes() > + { > + return new HashSet<Node>( nodeMap.values() ); > + } > + > + TraverserFactory traverserFactory = new TraverserFactory(); > + > + public class SubNetworkNode implements Node > + { > + Node underlyingNode; > + Map<RelationshipType,List<SubNetworkRelationship>> relationships = > new HashMap<RelationshipType,List<SubNetworkRelationship>>(); > + > + /** > + * @return > + * @see org.neo4j.api.core.Node#getId() > + */ > + public long getId() > + { > + return underlyingNode.getId(); > + } > + > + /** > + * @param arg0 > + * @return > + * @see > org.neo4j.api.core.PropertyContainer#getProperty(java.lang.String) > + */ > + public Object getProperty( String arg0 ) > + { > + return underlyingNode.getProperty( arg0 ); > + } > + > + /** > + * @param arg0 > + * @param arg1 > + * @return > + * @see > org.neo4j.api.core.PropertyContainer#getProperty(java.lang.String, > + * java.lang.Object) > + */ > + public Object getProperty( String arg0, Object arg1 ) > + { > + return underlyingNode.getProperty( arg0, arg1 ); > + } > + > + /** > + * @return > + * @see org.neo4j.api.core.PropertyContainer#getPropertyKeys() > + */ > + public Iterable<String> getPropertyKeys() > + { > + return underlyingNode.getPropertyKeys(); > + } > + > + /** > + * @return > + * @see org.neo4j.api.core.PropertyContainer#getPropertyValues() > + */ > + public Iterable<Object> getPropertyValues() > + { > + return underlyingNode.getPropertyValues(); > + } > + > + /** > + * @param arg0 > + * @return > + * @see > org.neo4j.api.core.PropertyContainer#hasProperty(java.lang.String) > + */ > + public boolean hasProperty( String arg0 ) > + { > + return underlyingNode.hasProperty( arg0 ); > + } > + > + /** > + * @param arg0 > + * @return > + * @see > org.neo4j.api.core.PropertyContainer#removeProperty(java.lang.String) > + */ > + public Object removeProperty( String arg0 ) > + { > + return underlyingNode.removeProperty( arg0 ); > + } > + > + /** > + * @param arg0 > + * @param arg1 > + * @see > org.neo4j.api.core.PropertyContainer#setProperty(java.lang.String, > + * java.lang.Object) > + */ > + public void setProperty( String arg0, Object arg1 ) > + { > + underlyingNode.setProperty( arg0, arg1 ); > + } > + > + public SubNetworkNode( Node underlyingNode ) > + { > + super(); > + this.underlyingNode = underlyingNode; > + } > + > + public Relationship createRelationshipTo( Node otherNode, > + RelationshipType type ) > + { > + SubNetworkNode otherSubNetworkNode = (SubNetworkNode) otherNode; > + Node otherUnderlyingNode = otherNode; > + // If otherNode is a subNetworkNode (of this network) > + if ( nodeMap.containsValue( otherNode ) ) > + { > + otherUnderlyingNode = otherSubNetworkNode.underlyingNode; > + } > + // Otherwise add it > + // TODO: or throw some error? > + else > + { > + otherSubNetworkNode = new SubNetworkNode( > otherUnderlyingNode ); > + nodeMap.put( otherUnderlyingNode, otherSubNetworkNode ); > + } > + Relationship underlyingRelationship = underlyingNode > + .createRelationshipTo( otherUnderlyingNode, type ); > + return addRelationship( underlyingRelationship ); > + } > + > + public void delete() > + { > + // TODO Auto-generated method stub > + } > + > + public Iterable<Relationship> getRelationships() > + { > + List<Relationship> result = new LinkedList<Relationship>(); > + for ( RelationshipType relationshipType : relationships.keySet() > ) > + { > + result.addAll( relationships.get( relationshipType ) ); > + } > + return result; > + } > + > + public Iterable<Relationship> getRelationships( > + RelationshipType... types ) > + { > + List<Relationship> result = new LinkedList<Relationship>(); > + for ( RelationshipType relationshipType : types ) > + { > + result.addAll( relationships.get( relationshipType ) ); > + } > + return result; > + } > + > + protected List<Relationship> getRelationshipsOfDirection( > + Iterable<Relationship> rels, Direction dir ) > + { > + List<Relationship> result = new LinkedList<Relationship>(); > + for ( Relationship relationship : rels ) > + { > + if ( dir.equals( Direction.BOTH ) > + || (dir.equals( Direction.OUTGOING ) && relationship > + .getStartNode().equals( this )) > + || (dir.equals( Direction.INCOMING ) && relationship > + .getEndNode().equals( this )) ) > + { > + result.add( relationship ); > + } > + } > + return result; > + } > + > + protected boolean containsRelationshipOfDirection( > + Iterable<Relationship> rels, Direction dir ) > + { > + for ( Relationship relationship : rels ) > + { > + if ( dir.equals( Direction.BOTH ) > + || (dir.equals( Direction.OUTGOING ) && relationship > + .getStartNode().equals( this )) > + || (dir.equals( Direction.INCOMING ) && relationship > + .getEndNode().equals( this )) ) > + { > + return true; > + } > + } > + return false; > + } > + > + public Iterable<Relationship> getRelationships( Direction dir ) > + { > + return getRelationshipsOfDirection( getRelationships(), dir ); > + } > + > + public Iterable<Relationship> getRelationships( RelationshipType > type, > + Direction dir ) > + { > + List<Relationship> result = new LinkedList<Relationship>(); > + result.addAll( relationships.get( type ) ); > + return result; > + } > + > + public Relationship getSingleRelationship( RelationshipType type, > + Direction dir ) > + { > + List<SubNetworkRelationship> rels = relationships.get( type ); > + if ( rels == null || rels.isEmpty() ) > + { > + return null; > + } > + return rels.get( 0 ); > + } > + > + public boolean hasRelationship() > + { > + return !relationships.isEmpty(); > + } > + > + public boolean hasRelationship( RelationshipType... types ) > + { > + for ( RelationshipType relationshipType : types ) > + { > + List<SubNetworkRelationship> rels = relationships > + .get( relationshipType ); > + if ( rels != null && !rels.isEmpty() ) > + { > + return true; > + } > + } > + return false; > + } > + > + public boolean hasRelationship( Direction dir ) > + { > + return containsRelationshipOfDirection( getRelationships(), dir > ); > + } > + > + public boolean hasRelationship( RelationshipType type, Direction dir > ) > + { > + return containsRelationshipOfDirection( getRelationships( type ), > + dir ); > + } > + > + public Traverser traverse( Order traversalOrder, > + StopEvaluator stopEvaluator, > + ReturnableEvaluator returnableEvaluator, > + RelationshipType relationshipType, Direction direction ) > + { > + if ( direction == null ) > + { > + throw new IllegalArgumentException( "Null direction" ); > + } > + if ( relationshipType == null ) > + { > + throw new IllegalArgumentException( "Null relationship type" > ); > + } > + // rest of parameters will be validated in traverser package > + return traverserFactory > + .createTraverser( traversalOrder, this, relationshipType, > + direction, stopEvaluator, returnableEvaluator ); > + } > + > + public Traverser traverse( Order traversalOrder, > + StopEvaluator stopEvaluator, > + ReturnableEvaluator returnableEvaluator, > + RelationshipType firstRelationshipType, Direction firstDirection, > + RelationshipType secondRelationshipType, Direction > secondDirection ) > + { > + if ( firstDirection == null || secondDirection == null ) > + { > + throw new IllegalArgumentException( "Null direction, " > + + "firstDirection=" + firstDirection + "secondDirection=" > + + secondDirection ); > + } > + if ( firstRelationshipType == null > + || secondRelationshipType == null ) > + { > + throw new IllegalArgumentException( "Null rel type, " > + + "first=" + firstRelationshipType + "second=" > + + secondRelationshipType ); > + } > + // rest of parameters will be validated in traverser package > + RelationshipType[] types = new RelationshipType[2]; > + Direction[] dirs = new Direction[2]; > + types[0] = firstRelationshipType; > + types[1] = secondRelationshipType; > + dirs[0] = firstDirection; > + dirs[1] = secondDirection; > + return traverserFactory.createTraverser( traversalOrder, this, > + types, dirs, stopEvaluator, returnableEvaluator ); > + } > + > + public Traverser traverse( Order traversalOrder, > + StopEvaluator stopEvaluator, > + ReturnableEvaluator returnableEvaluator, > + Object... relationshipTypesAndDirections ) > + { > + int length = relationshipTypesAndDirections.length; > + if ( (length % 2) != 0 || length == 0 ) > + { > + throw new IllegalArgumentException( "Variable argument > should " > + + " consist of [RelationshipType,Direction] pairs" ); > + } > + int elements = relationshipTypesAndDirections.length / 2; > + RelationshipType[] types = new RelationshipType[elements]; > + Direction[] dirs = new Direction[elements]; > + int j = 0; > + for ( int i = 0; i < elements; i++ ) > + { > + Object relType = relationshipTypesAndDirections[j++]; > + if ( !(relType instanceof RelationshipType) ) > + { > + throw new IllegalArgumentException( > + "Expected RelationshipType at var args pos " + (j - > 1) > + + ", found " + relType ); > + } > + types[i] = (RelationshipType) relType; > + Object direction = relationshipTypesAndDirections[j++]; > + if ( !(direction instanceof Direction) ) > + { > + throw new IllegalArgumentException( > + "Expected Direction at var args pos " + (j - 1) > + + ", found " + direction ); > + } > + dirs[i] = (Direction) direction; > + } > + return traverserFactory.createTraverser( traversalOrder, this, > + types, dirs, stopEvaluator, returnableEvaluator ); > + } > + } > + public class SubNetworkRelationship implements Relationship > + { > + Relationship underlyingRelationship; > + Node startNode; > + Node endNode; > + > + public SubNetworkRelationship( Relationship underlyingRelationship, > + Node startNode, Node endNode ) > + { > + super(); > + this.underlyingRelationship = underlyingRelationship; > + this.startNode = startNode; > + this.endNode = endNode; > + } > + > + /** > + * @return > + * @see org.neo4j.api.core.Relationship#getId() > + */ > + public long getId() > + { > + return underlyingRelationship.getId(); > + } > + > + /** > + * @param arg0 > + * @param arg1 > + * @return > + * @see > org.neo4j.api.core.PropertyContainer#getProperty(java.lang.String, > + * java.lang.Object) > + */ > + public Object getProperty( String arg0, Object arg1 ) > + { > + return underlyingRelationship.getProperty( arg0, arg1 ); > + } > + > + /** > + * @param arg0 > + * @return > + * @see > org.neo4j.api.core.PropertyContainer#getProperty(java.lang.String) > + */ > + public Object getProperty( String arg0 ) > + { > + return underlyingRelationship.getProperty( arg0 ); > + } > + > + /** > + * @return > + * @see org.neo4j.api.core.PropertyContainer#getPropertyKeys() > + */ > + public Iterable<String> getPropertyKeys() > + { > + return underlyingRelationship.getPropertyKeys(); > + } > + > + /** > + * @return > + * @see org.neo4j.api.core.PropertyContainer#getPropertyValues() > + */ > + public Iterable<Object> getPropertyValues() > + { > + return underlyingRelationship.getPropertyValues(); > + } > + > + /** > + * @return > + * @see org.neo4j.api.core.Relationship#getType() > + */ > + public RelationshipType getType() > + { > + return underlyingRelationship.getType(); > + } > + > + /** > + * @param arg0 > + * @return > + * @see > org.neo4j.api.core.PropertyContainer#hasProperty(java.lang.String) > + */ > + public boolean hasProperty( String arg0 ) > + { > + return underlyingRelationship.hasProperty( arg0 ); > + } > + > + /** > + * @param type > + * @return > + * @see > org.neo4j.api.core.Relationship#isType(org.neo4j.api.core.RelationshipType) > + */ > + public boolean isType( RelationshipType type ) > + { > + return underlyingRelationship.isType( type ); > + } > + > + /** > + * @param arg0 > + * @return > + * @see > org.neo4j.api.core.PropertyContainer#removeProperty(java.lang.String) > + */ > + public Object removeProperty( String arg0 ) > + { > + return underlyingRelationship.removeProperty( arg0 ); > + } > + > + /** > + * @param arg0 > + * @param arg1 > + * @see > org.neo4j.api.core.PropertyContainer#setProperty(java.lang.String, > + * java.lang.Object) > + */ > + public void setProperty( String arg0, Object arg1 ) > + { > + underlyingRelationship.setProperty( arg0, arg1 ); > + } > + > + public void delete() > + { > + // TODO Auto-generated method stub > + } > + > + public Node getEndNode() > + { > + return endNode; > + } > + > + public Node[] getNodes() > + { > + return new Node[] { startNode, endNode }; > + } > + > + public Node getOtherNode( Node node ) > + { > + if ( node.equals( startNode ) ) > + { > + return endNode; > + } > + if ( node.equals( endNode ) ) > + { > + return startNode; > + } > + throw new RuntimeException( "Node[" + node.getId() > + + "] not connected to this relationship[" + getId() + "]" ); > + } > + > + public Node getStartNode() > + { > + return startNode; > + } > + } > +} > > _______________________________________________ > Commits mailing list > [EMAIL PROTECTED] > https://lists.neo4j.org/mailman/listinfo/commits > > -- GTalk: neubauer.peter Skype peter.neubauer ICQ 18762544 GTalk neubauer.peter Phone +46704 106975 LinkedIn http://www.linkedin.com/in/neubauer http://www.neo4j.org - New Energy for Data - the Graph Database. http://www.ops4j.org - New Energy for OSS Communities - Open Participation Software. http://www.qi4j.org - New Energy for Java - Domain Driven Development. _______________________________________________ Neo mailing list User@lists.neo4j.org https://lists.neo4j.org/mailman/listinfo/user