@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());
}
