Examples with Direction org.neo4j.graphdb.Direction used on opensource projects

Example 11 with Direction

use of org.neo4j.graphdb.Direction in project neo4j by neo4j.

the class DijkstraDirectionTest method testDijkstraDirection3.

@Test
public void testDijkstraDirection3() {
    Relationship r1 = graph.makeEdge("start", "b");
    Relationship r2 = graph.makeEdge("c", "b");
    Relationship r3 = graph.makeEdge("c", "d");
    Relationship r4 = graph.makeEdge("e", "d");
    Relationship r5 = graph.makeEdge("e", "f");
    Relationship r6 = graph.makeEdge("g", "f");
    Relationship r7 = graph.makeEdge("g", "end");
    HashMap<Relationship, Direction> dirs = new HashMap<Relationship, Direction>();
    Dijkstra<Double> dijkstra = new Dijkstra<Double>((double) 0, graph.getNode("start"), graph.getNode("end"), new directionSavingCostEvaluator(dirs), new org.neo4j.graphalgo.impl.util.DoubleAdder(), new org.neo4j.graphalgo.impl.util.DoubleComparator(), Direction.BOTH, MyRelTypes.R1);
    dijkstra.getCost();
    assertEquals(Direction.OUTGOING, dirs.get(r1));
    assertEquals(Direction.INCOMING, dirs.get(r2));
    assertEquals(Direction.OUTGOING, dirs.get(r3));
    assertEquals(Direction.INCOMING, dirs.get(r4));
    assertEquals(Direction.OUTGOING, dirs.get(r5));
    assertEquals(Direction.INCOMING, dirs.get(r6));
    assertEquals(Direction.OUTGOING, dirs.get(r7));
}

Example 12 with Direction

use of org.neo4j.graphdb.Direction in project neo4j by neo4j.

the class DijkstraMultiplePathsTest method test8.

@Test
public void test8() {
    Relationship edgeAB = graph.makeEdge("a", "b");
    Relationship edgeBC = graph.makeEdge("b", "c");
    Relationship edgeCD = graph.makeEdge("c", "d");
    Relationship edgeDE = graph.makeEdge("d", "e");
    Relationship edgeAB2 = graph.makeEdge("a", "b2");
    Relationship edgeB2C = graph.makeEdge("b2", "c");
    Relationship edgeCD2 = graph.makeEdge("c", "d2");
    Relationship edgeD2E = graph.makeEdge("d2", "e");
    Dijkstra<Double> dijkstra = new Dijkstra<Double>(0.0, graph.getNode("a"), graph.getNode("e"), new CostEvaluator<Double>() {

        public Double getCost(Relationship relationship, Direction direction) {
            return 1.0;
        }
    }, new DoubleAdder(), new DoubleComparator(), Direction.OUTGOING, MyRelTypes.R1);
    // path discovery flags
    boolean pathBD = false;
    boolean pathB2D = false;
    boolean pathBD2 = false;
    boolean pathB2D2 = false;
    List<List<Relationship>> paths = dijkstra.getPathsAsRelationships();
    assertTrue(paths.size() == 4);
    for (List<Relationship> path : paths) {
        assertTrue(path.size() == 4);
        // first choice
        if (path.get(0).equals(edgeAB)) {
            assertTrue(path.get(1).equals(edgeBC));
        } else {
            assertTrue(path.get(0).equals(edgeAB2));
            assertTrue(path.get(1).equals(edgeB2C));
        }
        // second choice
        if (path.get(2).equals(edgeCD)) {
            assertTrue(path.get(3).equals(edgeDE));
        } else {
            assertTrue(path.get(2).equals(edgeCD2));
            assertTrue(path.get(3).equals(edgeD2E));
        }
        // combinations
        if (path.get(0).equals(edgeAB)) {
            if (path.get(2).equals(edgeCD)) {
                pathBD = true;
            } else if (path.get(2).equals(edgeCD2)) {
                pathBD2 = true;
            }
        } else {
            if (path.get(2).equals(edgeCD)) {
                pathB2D = true;
            } else if (path.get(2).equals(edgeCD2)) {
                pathB2D2 = true;
            }
        }
    }
    assertTrue(pathBD);
    assertTrue(pathB2D);
    assertTrue(pathBD2);
    assertTrue(pathB2D2);
}

Example 13 with Direction

use of org.neo4j.graphdb.Direction in project neo4j by neo4j.

the class DijkstraMultiplePathsTest method test7.

@Test
public void test7() {
    Relationship edgeAB = graph.makeEdge("a", "b");
    Relationship edgeBC = graph.makeEdge("b", "c");
    Relationship edgeCD = graph.makeEdge("c", "d");
    Relationship edgeDE = graph.makeEdge("d", "e");
    Relationship edgeAB2 = graph.makeEdge("a", "b2");
    Relationship edgeB2C = graph.makeEdge("b2", "c");
    Relationship edgeCD2 = graph.makeEdge("c", "d2");
    Relationship edgeD2E = graph.makeEdge("d2", "e");
    Dijkstra<Double> dijkstra = new Dijkstra<Double>(0.0, graph.getNode("a"), graph.getNode("e"), new CostEvaluator<Double>() {

        public Double getCost(Relationship relationship, Direction direction) {
            return 1.0;
        }
    }, new DoubleAdder(), new DoubleComparator(), Direction.OUTGOING, MyRelTypes.R1);
    // path discovery flags
    boolean pathBD = false;
    boolean pathB2D = false;
    boolean pathBD2 = false;
    boolean pathB2D2 = false;
    List<List<PropertyContainer>> paths = dijkstra.getPaths();
    assertTrue(paths.size() == 4);
    for (List<PropertyContainer> path : paths) {
        assertTrue(path.size() == 9);
        assertTrue(path.get(0).equals(graph.getNode("a")));
        assertTrue(path.get(4).equals(graph.getNode("c")));
        assertTrue(path.get(8).equals(graph.getNode("e")));
        // first choice
        if (path.get(2).equals(graph.getNode("b"))) {
            assertTrue(path.get(1).equals(edgeAB));
            assertTrue(path.get(3).equals(edgeBC));
        } else {
            assertTrue(path.get(1).equals(edgeAB2));
            assertTrue(path.get(2).equals(graph.getNode("b2")));
            assertTrue(path.get(3).equals(edgeB2C));
        }
        // second choice
        if (path.get(6).equals(graph.getNode("d"))) {
            assertTrue(path.get(5).equals(edgeCD));
            assertTrue(path.get(7).equals(edgeDE));
        } else {
            assertTrue(path.get(5).equals(edgeCD2));
            assertTrue(path.get(6).equals(graph.getNode("d2")));
            assertTrue(path.get(7).equals(edgeD2E));
        }
        // combinations
        if (path.get(2).equals(graph.getNode("b"))) {
            if (path.get(6).equals(graph.getNode("d"))) {
                pathBD = true;
            } else if (path.get(6).equals(graph.getNode("d2"))) {
                pathBD2 = true;
            }
        } else {
            if (path.get(6).equals(graph.getNode("d"))) {
                pathB2D = true;
            } else if (path.get(6).equals(graph.getNode("d2"))) {
                pathB2D2 = true;
            }
        }
    }
    assertTrue(pathBD);
    assertTrue(pathB2D);
    assertTrue(pathBD2);
    assertTrue(pathB2D2);
}

Example 14 with Direction

use of org.neo4j.graphdb.Direction in project neo4j by neo4j.

the class OrderedByTypeExpander method doExpand.

@Override
Iterator<Relationship> doExpand(final Path path, BranchState state) {
    final Node node = path.endNode();
    return new NestingIterator<Relationship, Pair<RelationshipType, Direction>>(orderedTypes.iterator()) {

        @Override
        protected Iterator<Relationship> createNestedIterator(Pair<RelationshipType, Direction> entry) {
            RelationshipType type = entry.first();
            Direction dir = entry.other();
            return ((dir == Direction.BOTH) ? node.getRelationships(type) : node.getRelationships(type, dir)).iterator();
        }
    };
}

Example 15 with Direction

use of org.neo4j.graphdb.Direction in project neo4j by neo4j.

the class NodeRelationshipCacheTest method shouldPutRandomStuff.

@Test
public void shouldPutRandomStuff() throws Exception {
    // GIVEN
    int nodes = 10_000;
    PrimitiveLongObjectMap<long[]> key = Primitive.longObjectMap(nodes);
    cache = new NodeRelationshipCache(NumberArrayFactory.HEAP, 1, 1000, base);
    // mark random nodes as dense (dense node threshold is 1 so enough with one increment
    cache.setHighNodeId(nodes);
    for (long nodeId = 0; nodeId < nodes; nodeId++) {
        if (random.nextBoolean()) {
            cache.incrementCount(nodeId);
        }
    }
    // WHEN
    for (int i = 0; i < 100_000; i++) {
        long nodeId = random.nextLong(nodes);
        boolean dense = cache.isDense(nodeId);
        Direction direction = random.among(Direction.values());
        long relationshipId = random.nextLong(1_000_000);
        long previousHead = cache.getAndPutRelationship(nodeId, direction, relationshipId, false);
        long[] keyIds = key.get(nodeId);
        int keyIndex = dense ? direction.ordinal() : 0;
        if (keyIds == null) {
            key.put(nodeId, keyIds = minusOneLongs(Direction.values().length));
        }
        assertEquals(keyIds[keyIndex], previousHead);
        keyIds[keyIndex] = relationshipId;
    }
}