@Test public void testGetOrCreateRelationship() throws Exception { final Transaction tx = gdb.beginTx(); final Node david = graphDatabase.createNode(map("name", "David")); final Node michael = graphDatabase.createNode(map("name", "Michael")); final Relationship rel1 = graphDatabase.getOrCreateRelationship( "knows", "whom", "david_michael", david, michael, "KNOWS", map("whom", "david_michael")); final Relationship rel2 = graphDatabase.getOrCreateRelationship( "knows", "whom", "david_michael", david, michael, "KNOWS", map("whom", "david_michael")); assertEquals("david_michael", rel1.getProperty("whom")); assertEquals("KNOWS", rel1.getType().name()); assertEquals(david, rel1.getStartNode()); assertEquals(michael, rel1.getEndNode()); assertEquals(rel1, rel2); assertEquals( rel1, gdb.index().forRelationships("knows").get("whom", "david_michael").getSingle()); tx.success(); tx.finish(); }
@Override public List<String> completionCandidates(String partOfLine, Session session) { String lastWord = TextUtil.lastWordOrQuoteOf(partOfLine, false); if (lastWord.startsWith("-")) { return super.completionCandidates(partOfLine, session); } try { TreeSet<String> result = new TreeSet<String>(); NodeOrRelationship current = getCurrent(session); if (current.isNode()) { // TODO Check if -r is supplied Node node = current.asNode(); for (Node otherNode : RelationshipToNodeIterable.wrap(node.getRelationships(), node)) { long otherNodeId = otherNode.getId(); String title = findTitle(getServer(), session, otherNode); if (title != null) { if (!result.contains(title)) { maybeAddCompletionCandidate(result, title + "," + otherNodeId, lastWord); } } maybeAddCompletionCandidate(result, "" + otherNodeId, lastWord); } } else { maybeAddCompletionCandidate(result, START_ALIAS, lastWord); maybeAddCompletionCandidate(result, END_ALIAS, lastWord); Relationship rel = current.asRelationship(); maybeAddCompletionCandidate(result, "" + rel.getStartNode().getId(), lastWord); maybeAddCompletionCandidate(result, "" + rel.getEndNode().getId(), lastWord); } return new ArrayList<String>(result); } catch (ShellException e) { e.printStackTrace(); return super.completionCandidates(partOfLine, session); } }
private Object toJsonCompatible(Object value) { if (value instanceof Node) { final Node node = (Node) value; final Map<String, Object> result = SubGraph.toMap(node); result.put("_id", node.getId()); return result; } if (value instanceof Relationship) { final Relationship relationship = (Relationship) value; final Map<String, Object> result = SubGraph.toMap(relationship); result.put("_id", relationship.getId()); result.put("_start", relationship.getStartNode().getId()); result.put("_end", relationship.getEndNode().getId()); result.put("_type", relationship.getType().name()); return result; } if (value instanceof Iterable) { final List<Object> result = new ArrayList<Object>(); for (Object inner : (Iterable) value) { result.add(toJsonCompatible(inner)); } return result; } return value; }
private boolean isConnected(NodeOrRelationship current, TypedId newId) throws ShellException { if (current.isNode()) { Node currentNode = current.asNode(); for (Relationship rel : currentNode.getRelationships()) { if (newId.isNode()) { if (rel.getOtherNode(currentNode).getId() == newId.getId()) { return true; } } else { if (rel.getId() == newId.getId()) { return true; } } } } else { if (newId.isRelationship()) { return false; } Relationship relationship = current.asRelationship(); if (relationship.getStartNode().getId() == newId.getId() || relationship.getEndNode().getId() == newId.getId()) { return true; } } return false; }
@Test public void removeNodesWithARelation() { int originalNodeCount = countNodesOf(graphDb); int removedNodeCount = 0; Transaction tx = graphDb.beginTx(); try { Set<Node> toRemove = new HashSet<Node>(); for (Node node : graphDb.getAllNodes()) { for (Relationship relationship : node.getRelationships(RelationType.ON)) { toRemove.add(relationship.getStartNode()); toRemove.add(relationship.getEndNode()); relationship.delete(); } } for (Node node : toRemove) { node.delete(); removedNodeCount++; } tx.success(); } finally { tx.finish(); } int finalNodeCount = countNodesOf(graphDb); assertEquals( Integer.valueOf(originalNodeCount), Integer.valueOf(finalNodeCount + removedNodeCount)); }
public Relationship _findRelationship( Iterable<Relationship> rels, long nodeId, Direction direction) { for (Relationship rel : rels) { switch (direction) { case INCOMING: if (rel.getStartNode().getId() == nodeId) return rel; break; case OUTGOING: if (rel.getEndNode().getId() == nodeId) return rel; case BOTH: if (rel.getStartNode().getId() == nodeId || rel.getEndNode().getId() == nodeId) return rel; } } return null; }
public static String withArrows(Relationship relationship, String displayName, Node leftNode) { if (relationship.getStartNode().equals(leftNode)) { return "-" + displayName + "->"; } else if (relationship.getEndNode().equals(leftNode)) { return "<-" + displayName + "-"; } throw new IllegalArgumentException( leftNode + " is neither start nor end node to " + relationship); }
private Node getIndexNodeParent(Node indexNode) { Relationship relationship = indexNode.getSingleRelationship(RTreeRelationshipTypes.RTREE_CHILD, Direction.INCOMING); if (relationship == null) { return null; } else { return relationship.getStartNode(); } }
private void appendRelationship(PrintWriter out, Relationship rel) { out.print("create "); out.print(identifier(rel.getStartNode())); out.print("-[:"); out.print(quote(rel.getType().name())); formatProperties(out, rel); out.print("]->"); out.print(identifier(rel.getEndNode())); out.println(); }
@Test public void testTraverseToNeighbour() { final Relationship rel = relationship(); final TraversalDescription traversalDescription = RestTraversal.description().maxDepth(1).breadthFirst(); System.out.println("traversalDescription = " + traversalDescription); final Traverser traverser = traversalDescription.traverse(rel.getStartNode()); final Iterable<Node> nodes = traverser.nodes(); Assert.assertEquals(rel.getEndNode(), nodes.iterator().next()); }
public String sumNodeContents(Node node) { StringBuffer result = new StringBuffer(); for (Relationship rel : node.getRelationships()) { if (rel.getStartNode().equals(node)) { result.append( rel.getStartNode() + " ---[" + rel.getType().name() + "]--> " + rel.getEndNode()); } else { result.append( rel.getStartNode() + " <--[" + rel.getType().name() + "]--- " + rel.getEndNode()); } result.append("\n"); } for (String key : node.getPropertyKeys()) { for (Object value : propertyValueAsArray(node.getProperty(key))) { result.append("*" + key + "=[" + value + "]"); result.append("\n"); } } return result.toString(); }
static boolean matchDirection(Direction dir, Node start, Relationship rel) { switch (dir) { case INCOMING: return rel.getEndNode().equals(start); case OUTGOING: return rel.getStartNode().equals(start); case BOTH: return true; } return true; }
@Test @Transactional public void shouldCreateRelationshipWithProperty() throws Exception { Relationship relationship = neo4jTemplate.createRelationshipBetween(referenceNode, node1, "has", map("name", "rel2")); assertNotNull(relationship); assertEquals(referenceNode, relationship.getStartNode()); assertEquals(node1, relationship.getEndNode()); assertEquals(HAS.name(), relationship.getType().name()); assertEquals("rel2", relationship.getProperty("name", "not set")); }
static Edge addEdge(Graph graph, Relationship relationship) { Edge edge = graph.getEdge(relationship.getId()); if (null == edge) { Vertex outVertex = addNode(graph, relationship.getStartNode()); Vertex inVertex = addNode(graph, relationship.getEndNode()); String label = relationship.getType().name(); // TODO #152 add CurieUtil to resolve IRI to Curie edge = graph.addEdge(relationship.getId(), outVertex, inVertex, label); copyProperties(relationship, edge); } return edge; }
@Test public void testPun() { Node i = getNode("http://example.org/i"); Node j = getNode("http://example.org/j"); Node k = getNode("http://example.org/k"); RelationshipType p = DynamicRelationshipType.withName("p"); Relationship relationship = getOnlyElement(GraphUtil.getRelationships(i, j, p)); assertThat("OPE edge should start with the subject.", relationship.getStartNode(), is(i)); assertThat("OPE edge should end with the target.", relationship.getEndNode(), is(j)); relationship = getOnlyElement(GraphUtil.getRelationships(i, k, OwlRelationships.RDFS_SUBCLASS_OF)); assertThat("Subclass edge should start with i.", relationship.getStartNode(), is(i)); assertThat("Subclass edge should end with k.", relationship.getEndNode(), is(k)); assertThat( "i is both a class an a named individual", i.getLabels(), is( IsIterableContainingInAnyOrder.containsInAnyOrder( OwlLabels.OWL_CLASS, OwlLabels.OWL_NAMED_INDIVIDUAL))); }
@Override public S getSourceNode() { try { NodeFactory<S> nodeFactory = new NodeFactory<>(securityContext); return nodeFactory.instantiate(dbRelationship.getStartNode()); } catch (FrameworkException t) { // ignore FrameworkException but let NotInTransactionException pass } return null; }
/** * Default constructor * * @param relationship the relation */ public DotEdge(Relationship relationship) { Node startNode = relationship.getStartNode(); this.startId = ShapeIdPrefix.fromNode(startNode) + startNode.getId(); Node endNode = relationship.getEndNode(); this.endId = ShapeIdPrefix.fromNode(endNode) + endNode.getId(); if (NodeUtils.isScoperelation(relationship.getType())) { this.edgeStyle = EdgeStyle.dotted; } else { this.edgeStyle = EdgeStyle.solid; } this.label = relationship.getType().toString(); }
@Test public void testDirectedRelationship() { Node node1 = getGraphDb().createNode(); Node node2 = getGraphDb().createNode(); Relationship rel2 = node1.createRelationshipTo(node2, MyRelTypes.TEST); Relationship rel3 = node2.createRelationshipTo(node1, MyRelTypes.TEST); Node[] nodes = rel2.getNodes(); assertEquals(2, nodes.length); assertTrue(nodes[0].equals(node1) && nodes[1].equals(node2)); nodes = rel3.getNodes(); assertEquals(2, nodes.length); assertTrue(nodes[0].equals(node2) && nodes[1].equals(node1)); assertEquals(node1, rel2.getStartNode()); assertEquals(node2, rel2.getEndNode()); assertEquals(node2, rel3.getStartNode()); assertEquals(node1, rel3.getEndNode()); Relationship relArray[] = getRelationshipArray(node1.getRelationships(MyRelTypes.TEST, Direction.OUTGOING)); assertEquals(1, relArray.length); assertEquals(rel2, relArray[0]); relArray = getRelationshipArray(node1.getRelationships(MyRelTypes.TEST, Direction.INCOMING)); assertEquals(1, relArray.length); assertEquals(rel3, relArray[0]); relArray = getRelationshipArray(node2.getRelationships(MyRelTypes.TEST, Direction.OUTGOING)); assertEquals(1, relArray.length); assertEquals(rel3, relArray[0]); relArray = getRelationshipArray(node2.getRelationships(MyRelTypes.TEST, Direction.INCOMING)); assertEquals(1, relArray.length); assertEquals(rel2, relArray[0]); rel2.delete(); rel3.delete(); node1.delete(); node2.delete(); }
public Dataset getParentDataset() { Dataset d = null; int ctr = 0; for (Relationship r : backingNode.getRelationships(PelagiosRelationships.GEOANNOTATION)) { // Can only have 1 relationship of type RECORD d = new DatasetImpl(r.getStartNode()); ctr++; } // Sanity checks if (ctr > 1) throw new RuntimeException( "Graph inconsistency: annotation referenced by " + ctr + " datasets"); if (d == null) throw new RuntimeException("Graph inconsistency: annotation not referenced by any dataset"); return d; }
@Test public void testDirectedRelationship1() { Node node1 = getGraphDb().getNodeById(node1Id); Relationship rel = node1.getSingleRelationship(MyRelTypes.TEST, Direction.BOTH); Node nodes[] = rel.getNodes(); assertEquals(2, nodes.length); Node node2 = getGraphDb().getNodeById(node2Id); assertTrue(nodes[0].equals(node1) && nodes[1].equals(node2)); assertEquals(node1, rel.getStartNode()); assertEquals(node2, rel.getEndNode()); Relationship relArray[] = getRelationshipArray(node1.getRelationships(MyRelTypes.TEST, Direction.OUTGOING)); assertEquals(1, relArray.length); assertEquals(rel, relArray[0]); relArray = getRelationshipArray(node2.getRelationships(MyRelTypes.TEST, Direction.INCOMING)); assertEquals(1, relArray.length); assertEquals(rel, relArray[0]); }
// example path: // (start)--[WALK1,1190]-->(hub)--[HUBBUS1,49581]-->(hub)--[53.36179430400081-6.299620132568407,1224]-->(end) public DirectionsList convertOneBusPath(WeightedPath path, double time) { int count = 0; double cost = 0; double deptTime = 0; List<Node> busList = new ArrayList<Node>(); for (Relationship relationship : path.relationships()) { if (count == 0) // lat1lon1 { double distanceInKm = (Double) relationship.getProperty(Connection.DISTANCE); double distanceInMins = Math.round(20 * distanceInKm * 1e2) / 1e2; walks.add(new DirectionsWalk(distanceInMins, relationship.getStartNode(), relationship)); Node stop = stopLayer.get(Stop.STOPID, (String) relationship.getProperty(Stop.STOPID)).getSingle(); busList.add(stop); deptTime = (Double) relationship.getProperty(Connection.TIME); cost += (Double) stop.getProperty(Stop.TIMETOHUB); } if (count == 1) // hubbus1 { cost += (Double) relationship.getProperty(Connection.COST); } if (count == 2) // lat2lon2 { Node stop = stopLayer.get(Stop.STOPID, (String) relationship.getProperty(Stop.STOPID)).getSingle(); cost += (Double) stop.getProperty(Stop.TIMEFROMHUB); busList.add(stop); routes.add(new DirectionsRoute(deptTime, cost, busList)); double distanceInKm = (Double) relationship.getProperty(Connection.DISTANCE); double distanceInMins = Math.round(20 * distanceInKm * 1e2) / 1e2; walks.add(new DirectionsWalk(distanceInMins, relationship, relationship.getEndNode())); } count++; } directionsList.add(new Directions(routes, walks)); // Add Total cost return directionsList; }
private synchronized void initialize() { if (subgraphs != null) return; Map<Node, String> mappings = new HashMap<Node, String>(); subgraphs = new HashMap<String, Collection<Node>>(); generic = new ArrayList<Node>(); for (Node node : nodes()) { if (mappings.containsKey(node)) continue; String subgraph = subgraphFor(node); if (!subgraphs.containsKey(subgraph) && subgraph != null) { subgraphs.put(subgraph, new ArrayList<Node>()); } mappings.put(node, subgraph); } relationships = new ArrayList<Relationship>(); for (Relationship rel : relationships()) { if (mappings.containsKey(rel.getStartNode()) && mappings.containsKey(rel.getEndNode())) { relationships.add(rel); } } for (Map.Entry<Node, String> e : mappings.entrySet()) { (e.getValue() == null ? generic : subgraphs.get(e.getValue())).add(e.getKey()); } }
/** * Called when a relationship of this combinedType is instatiated. Please note that a relationship * can (and will) be instantiated several times during a normal rendering turn. */ @Override public void onRelationshipInstantiation() { try { if (dbRelationship != null) { Node startNode = dbRelationship.getStartNode(); Node endNode = dbRelationship.getEndNode(); if ((startNode != null) && (endNode != null) && startNode.hasProperty(GraphObject.id.dbName()) && endNode.hasProperty(GraphObject.id.dbName())) { cachedStartNodeId = (String) startNode.getProperty(GraphObject.id.dbName()); cachedEndNodeId = (String) endNode.getProperty(GraphObject.id.dbName()); } } } catch (Throwable t) { } }
private Object toJsonCompatible(Object value) { if (value instanceof Node) { final Node node = (Node) value; final Map<String, Object> result = SubGraph.toMap((PropertyContainer) node); result.put("_id", node.getId()); final List<String> labelNames = SubGraph.getLabelNames(node); if (!labelNames.isEmpty()) result.put("_labels", labelNames); return result; } if (value instanceof Relationship) { final Relationship relationship = (Relationship) value; final Map<String, Object> result = SubGraph.toMap((PropertyContainer) relationship); result.put("_id", relationship.getId()); result.put("_start", relationship.getStartNode().getId()); result.put("_end", relationship.getEndNode().getId()); result.put("_type", relationship.getType().name()); return result; } if (value instanceof Map) { @SuppressWarnings("unchecked") Map<String, Object> map = (Map<String, Object>) value; final Map<String, Object> result = new LinkedHashMap<>(map.size()); for (Map.Entry<String, Object> entry : map.entrySet()) { result.put(entry.getKey(), toJsonCompatible(entry.getValue())); } return result; } if (value instanceof Iterable) { final List<Object> result = new ArrayList<>(); for (Object inner : (Iterable) value) { result.add(toJsonCompatible(inner)); } return result; } return value; }
@Override public Map<String, Set<Long>> extract( List<DocGraph> docGraphs, DocGraphFilterFunction filterFunc, Set<String> resourceClasses, Set<String> documentClasses) { // pattern-document graph associations R_D Map<String, Set<Long>> associations = new HashMap<String, Set<Long>>(); // init path finder initFinder(); // G_D(filtered) <- G_D.where({G_d|filter(G_D)}) Set<DocGraph> filteredDocGraphs = new HashSet<DocGraph>(); if (filterFunc == null) { filteredDocGraphs.addAll(docGraphs); } else { for (DocGraph docGraph : docGraphs) { if (filterFunc.filter(docGraph)) { filteredDocGraphs.add(docGraph); } } } Set<Node> relevantResources = null; Set<Node> relevantDocuments = null; String r = null; Node v_p = null; boolean validPath = true; int pCnt = 0; log.info(String.format("Starting analysis of %d document graphs", filteredDocGraphs.size())); for (DocGraph docGraph : filteredDocGraphs) { log.info( String.format( "Analyzing DocGraph[%d] (%d, %d)", docGraph.getId(), docGraph.getNodeCount(), docGraph.getEdgeCount())); pCnt = 0; // V_R <- G_d.V.where({v|tau(mu(v)) in C_R}) relevantResources = filterNodesByClass(docGraph.getNodes(), resourceClasses); // V_R <- G_d.V.where({v|tau(mu(v)) in C_D}) relevantDocuments = filterNodesByClass(docGraph.getNodes(), documentClasses); preProcessGraph(docGraph, resourceClasses); try (Transaction tx = graphDB.beginTx()) { for (Node v_r : relevantResources) { for (Node v_d : relevantDocuments) { // P <- G_d.paths(v_R,v_D) for (Path p : finder.findAllPaths(v_r, v_d)) { validPath = true; r = String.format("%s", v_r.getProperty(Constants.ID_KEY)); v_p = v_r; for (Relationship e : p.relationships()) { if (e.getStartNode().getId() == v_p.getId()) { if (getNodeSuperClass(e.getEndNode()) .equals(Constants.NODE_SUPER_CLASS_RESOURCE_VALUE)) { validPath = false; break; } r = String.format( "%s-%s->%s", r, e.getType().name(), getNodeClass(e.getEndNode())); v_p = e.getEndNode(); } else { if (getNodeSuperClass(e.getStartNode()) .equals(Constants.NODE_SUPER_CLASS_RESOURCE_VALUE)) { validPath = false; break; } r = String.format( "%s<-%s-%s", r, e.getType().name(), getNodeClass(e.getStartNode())); v_p = e.getStartNode(); } } // R_D.add(<r, G_d>) if (validPath) { associations = addPatternDocGraphAssociation(associations, r, docGraph); pCnt++; } } } } tx.success(); } log.info(String.format("%d patterns in DocGraph[%d]", pCnt, docGraph.getId())); } return associations; }
// example path: // (start)--[WALK1,25037]-->(hub)--[HUBBUS1,44652]-->(hub)--[TRANSFER,44624]-->(hubtransfer)--[WALK2,61370]-->(hubtransfer)--[O0033,48991]-->(hub)--[HUBBUS1,49028]-->(hub)--[53.373665-6.251902,25283]-->(end) public DirectionsList convertTwoBusPath(WeightedPath path, double time) { int count = 0; double cost = 0; double deptTime = 0; List<Node> busList1 = new ArrayList<Node>(); List<Node> busList2 = new ArrayList<Node>(); for (Relationship relationship : path.relationships()) { if (count == 0) // lat1lon1 { double distanceInKm = (Double) relationship.getProperty(Connection.DISTANCE); double distanceInMins = Math.round(20 * distanceInKm * 1e2) / 1e2; walks.add(new DirectionsWalk(distanceInMins, relationship.getStartNode(), relationship)); Node stop = stopLayer.get(Stop.STOPID, (String) relationship.getProperty(Stop.STOPID)).getSingle(); busList1.add(stop); deptTime = (Double) relationship.getProperty(Connection.TIME); cost += (Double) stop.getProperty(Stop.TIMETOHUB); } if (count == 1) // hubbus1 { cost += (Double) relationship.getProperty(Connection.COST); busList1.add(relationship.getEndNode()); routes.add(new DirectionsRoute(deptTime, cost, busList1)); } if (count == 3) // walk2 { double distanceInMins = (Double) relationship.getProperty(Connection.COST); cost += distanceInMins; walks.add( new DirectionsWalk( distanceInMins, relationship.getStartNode(), relationship.getEndNode())); } if (count == 5) // hubbus1 { busList2.add(relationship.getStartNode()); double[] transferTimes = (double[]) relationship.getStartNode().getProperty(Hub.DEPTTIMES); int insertionPoint = Arrays.binarySearch(transferTimes, (deptTime + cost)); insertionPoint = (insertionPoint < 0) ? ((insertionPoint * -1) - 1) : insertionPoint; // ( -( insertion point ) - 1) if (insertionPoint != transferTimes.length) deptTime = transferTimes[insertionPoint]; cost = 0.0; cost += (Double) relationship.getProperty(Connection.COST); } if (count == 6) // lat2lon2 { Node stop = stopLayer.get(Stop.STOPID, (String) relationship.getProperty(Stop.STOPID)).getSingle(); cost += (Double) stop.getProperty(Stop.TIMEFROMHUB); busList2.add(stop); routes.add(new DirectionsRoute(deptTime, cost, busList2)); double distanceInKm = (Double) relationship.getProperty(Connection.DISTANCE); double distanceInMins = Math.round(20 * distanceInKm * 1e2) / 1e2; walks.add(new DirectionsWalk(distanceInMins, relationship, relationship.getEndNode())); } count++; } directionsList.add(new Directions(routes, walks)); return directionsList; }
/** * This is the simplest node scoring criterion we could come up with: just the number of * descendants. Joseph has done some work coming up with a better one that included the structure * of the tree. * * @param node * @return */ private double getScoreNodeCount(Relationship rel) { return nodeMrcaTipsAndInternal.get(rel.getStartNode().getId()).cardinality(); }
@Override List<Relationship> selectRelsForNode(Node n) { if (VERBOSE) { print("\nvisiting node ", n, "\nlooking for best non-overlapping rels"); } // collect the relationships Map<Node, Relationship> bestRelForNode = new HashMap<Node, Relationship>(); List<Relationship> singletons = new ArrayList<Relationship>(); for (Relationship r : availableRelsForSynth( n, RelType.STREECHILDOF, RelType.TAXCHILDOF)) { // getALLStreeAndTaxRels(n)) { // if (mrcaTips(r).length == 1) { singletons.add(r); continue; } // skip *all* singletons if (mrcaTips(r.getStartNode()).size() == 1) { singletons.add(r); continue; } // skip *all* singletons // for non-singletons, just keep one (arbitrary) rel pointing at each child node -- the others // are redundant bestRelForNode.put(r.getStartNode(), r); } if (bestRelForNode.isEmpty() && VERBOSE) { if (singletons.isEmpty()) { print("this must be a tip."); } else { print("only singletons found."); } } // collect the set of non-redundant rels List<Relationship> relsForMWIS = new ArrayList<Relationship>(bestRelForNode.values()); // get all the best non-singleton rels and collect the ids of all descendant tips List<Long> bestRelIds = findBestNonOverlapping(relsForMWIS); // TODO: this is a bit of a mess. we should convert findBestNonOverlapping to return // relationship objects instead of ids, the only reason we return ids is because that's // what's used by the mwis List<Relationship> bestRels = new ArrayList<Relationship>(); for (Long id : bestRelIds) { bestRels.add(G.getRelationshipById(id)); } // List<Node> bestRelStartNodes = new ArrayList<Node>(); // for (Long id : bestRelIds) { // bestRelStartNodes.add(G.getRelationshipById(id).getStartNode()); } TLongBitArraySet included = new TLongBitArraySet(mrcaTipsAndInternal(bestRels)); if (VERBOSE) { for (Relationship r : bestRels) { print("selected source tree rel ", r, ": ", r.getStartNode(), " -> ", r.getEndNode()); } } // add the singleton rels that aren't included in any rels already selected for (Relationship s : singletons) { // long[] l = mrcaTips(s); TLongBitArraySet l = mrcaTips(s.getStartNode()); assert l.size() == 1; long singleTipId = l.get(0); // is this the correct method? if (!included.contains(singleTipId)) { included.add(singleTipId); bestRels.add(s); if (VERBOSE) { System.out.println( "adding singleton rel " + s + ": " + s.getStartNode() + " -> " + s.getEndNode()); } } } return bestRels; }
Node getStartNode() { return entryRelationship.getStartNode(); }
/** * Construct a representation from a Neo4j relationship. * * @param relationship to create the representation from. Must not be <code>null</code>. * @param properties keys of properties to be included in the representation. Can be <code>null * </code>, which represents all. Empty array represents none. */ public RelationshipRepresentation(Relationship relationship, String[] properties) { super(relationship, properties); startNodeGraphId = relationship.getStartNode().getId(); endNodeGraphId = relationship.getEndNode().getId(); setType(relationship.getType().name()); }