Exemplo n.º 1
0
  /** Read the edges from the temp file and load them to the graph. */
  private void readFromTempEdges(final Input input, final Graph graphToWriteTo) {
    while (!input.eof()) {
      // in this case the outId is the id assigned by the graph
      Object next = kryo.readClassAndObject(input);
      while (!next.equals(EdgeTerminator.INSTANCE)) {
        final List<Object> edgeArgs = new ArrayList<>();
        final DetachedEdge detachedEdge = (DetachedEdge) next;
        final Vertex vOut =
            graphToWriteTo.v(detachedEdge.iterators().vertexIterator(Direction.OUT).next().id());
        final Vertex inV =
            graphToWriteTo.v(detachedEdge.iterators().vertexIterator(Direction.IN).next().id());

        detachedEdge
            .iterators()
            .propertyIterator()
            .forEachRemaining(p -> edgeArgs.addAll(Arrays.asList(p.key(), p.value())));
        // detachedEdge.iterators().hiddenPropertyIterator().forEachRemaining(p ->
        // edgeArgs.addAll(Arrays.asList(Graph.Key.hide(p.key()), p.value())));

        appendToArgList(edgeArgs, T.id, detachedEdge.id());

        vOut.addEdge(detachedEdge.label(), inV, edgeArgs.toArray());

        next = kryo.readClassAndObject(input);
      }

      // vertex terminator
      kryo.readClassAndObject(input);
    }
  }
  @Test
  public void shouldAppendPartitionToVertex() {
    final Vertex v = g.addVertex("any", "thing");

    assertNotNull(v);
    assertEquals("thing", v.property("any").value());
    assertEquals("A", v.property(partition).value());
  }
Exemplo n.º 3
0
  @Before
  public void setup() {
    final Vertex v = mock(Vertex.class);
    when(v.id()).thenReturn("1");
    when(v.label()).thenReturn("l");

    this.mv = DetachedVertex.detach(v);
  }
 private void removeEdge(Vertex v) {
   Set<Edge> edges = UMLG.get().getEdgesBetween(this.vertex, v, this.getLabel());
   for (Edge edge : edges) {
     Vertex associationClassVertex =
         UMLG.get().v(edge.value(UmlgCollection.ASSOCIATION_CLASS_VERTEX_ID));
     // The remove code will delete all in and out edges
     associationClassVertex.remove();
   }
 }
Exemplo n.º 5
0
  @Test
  public void shouldNotEvaluateToEqualDifferentId() {
    final Vertex v = mock(Vertex.class);
    when(v.id()).thenReturn("2");
    when(v.label()).thenReturn("l");

    final DetachedVertex mv1 = DetachedVertex.detach(v);
    assertFalse(mv1.equals(this.mv));
  }
Exemplo n.º 6
0
 private Vertex getDeletionVertex(Graph g) {
   Vertex root = g.v(0L);
   if (root != null && root.outE(UmlgGraph.DELETED_VERTEX_EDGE).hasNext()) {
     return root.outE(UmlgGraph.DELETED_VERTEX_EDGE).next().inV().next();
   } else {
     throw new IllegalStateException(
         "The root node or deletion vertex is not present. It must be created at graph initialization!");
   }
 }
Exemplo n.º 7
0
    @Override
    public void serialize(
        final GraphSONVertex directionalVertex,
        final JsonGenerator jsonGenerator,
        final SerializerProvider serializerProvider)
        throws IOException, JsonGenerationException {
      final Vertex vertex = directionalVertex.getVertexToSerialize();
      jsonGenerator.writeStartObject();
      jsonGenerator.writeObjectField(GraphSONTokens.ID, vertex.getId());
      jsonGenerator.writeStringField(GraphSONTokens.LABEL, vertex.getLabel());
      jsonGenerator.writeStringField(GraphSONTokens.TYPE, GraphSONTokens.VERTEX);

      if (normalize) {
        jsonGenerator.writeObjectFieldStart(GraphSONTokens.PROPERTIES);
        vertex
            .getProperties()
            .values()
            .stream()
            .sorted(Comparators.PROPERTY_COMPARATOR)
            .forEachOrdered(
                FunctionUtils.wrapConsumer(
                    e -> jsonGenerator.writeObjectField(e.getKey(), e.get())));
        jsonGenerator.writeEndObject();
      } else {
        jsonGenerator.writeObjectFieldStart(GraphSONTokens.PROPERTIES);
        vertex
            .getProperties()
            .values()
            .forEach(
                FunctionUtils.wrapConsumer(
                    e -> jsonGenerator.writeObjectField(e.getKey(), e.get())));
        jsonGenerator.writeEndObject();
      }

      if (directionalVertex.getDirection() == Direction.BOTH
          || directionalVertex.getDirection() == Direction.OUT) {
        jsonGenerator.writeArrayFieldStart(GraphSONTokens.OUT);
        if (normalize)
          vertex
              .outE()
              .order(Comparators.HELD_EDGE_COMPARATOR)
              .forEach(FunctionUtils.wrapConsumer(jsonGenerator::writeObject));
        else vertex.outE().forEach(FunctionUtils.wrapConsumer(jsonGenerator::writeObject));
        jsonGenerator.writeEndArray();
      }

      if (directionalVertex.getDirection() == Direction.BOTH
          || directionalVertex.getDirection() == Direction.IN) {
        jsonGenerator.writeArrayFieldStart(GraphSONTokens.IN);
        if (normalize)
          vertex
              .inE()
              .order(Comparators.HELD_EDGE_COMPARATOR)
              .forEach(FunctionUtils.wrapConsumer(jsonGenerator::writeObject));
        else vertex.inE().forEach(FunctionUtils.wrapConsumer(jsonGenerator::writeObject));
        jsonGenerator.writeEndArray();
      }
      jsonGenerator.writeEndObject();
    }
  @Test
  public void shouldWrapProperties() {
    final Vertex v = g.addVertex("any", "a");
    final Edge e = v.addEdge("to", v, "all", "a");

    assertTrue(v.property("any") instanceof StrategyWrappedProperty);
    assertTrue(v.properties().get("any") instanceof StrategyWrappedProperty);

    assertTrue(e.property("all") instanceof StrategyWrappedProperty);
    assertTrue(e.properties().get("all") instanceof StrategyWrappedProperty);

    assertTrue(g.V().property("any").next() instanceof StrategyWrappedProperty);
    assertTrue(g.E().property("any").next() instanceof StrategyWrappedProperty);
  }
  @Test
  public void shouldThrowExceptionOnvInDifferentPartition() {
    final Vertex vA = g.addVertex("any", "a");
    assertEquals(vA.id(), g.v(vA.id()).id());

    final PartitionGraphStrategy strategy =
        (PartitionGraphStrategy) ((StrategyWrappedGraph) g).strategy().getGraphStrategy().get();
    strategy.clearReadPartitions();

    try {
      g.v(vA.id());
    } catch (Exception ex) {
      final Exception expected = Graph.Exceptions.elementNotFound(Vertex.class, vA.id());
      assertEquals(expected.getClass(), ex.getClass());
      assertEquals(expected.getMessage(), ex.getMessage());
    }
  }
Exemplo n.º 10
0
 @Override
 public UnaryOperator<Supplier<Void>> getRemoveElementStrategy(
     final Strategy.Context<? extends StrategyWrappedElement> ctx) {
   if (ctx.getCurrent() instanceof StrategyWrappedVertex) {
     return (t) ->
         () -> {
           Vertex v = ((StrategyWrappedVertex) ctx.getCurrent()).getBaseVertex();
           v.bothE().forEach(e -> e.remove());
           getDeletionVertex(ctx.getBaseGraph()).addEdge(UmlgGraph.DELETION_VERTEX, v);
           v.properties().values().forEach(p -> p.remove());
           v.property("_deleted", true);
           return null;
         };
   } else {
     return UnaryOperator.identity();
   }
 }
Exemplo n.º 11
0
 public void makeAGraph() {
   Graph graph = EmptyGraph.instance();
   Vertex marko = graph.addVertex(T.label, "person", T.id, 1, "name", "marko", "age", 29);
   Vertex vadas = graph.addVertex(T.label, "person", T.id, 2, "name", "vadas", "age", 27);
   Vertex lop = graph.addVertex(T.label, "software", T.id, 3, "name", "lop", "lang", "java");
   Vertex josh = graph.addVertex(T.label, "person", T.id, 4, "name", "josh", "age", 32);
   Vertex ripple = graph.addVertex(T.label, "software", T.id, 5, "name", "ripple", "lang", "java");
   Vertex peter = graph.addVertex(T.label, "person", T.id, 6, "name", "peter", "age", 35);
   marko.addEdge("knows", vadas, T.id, 7, "weight", 0.5f);
   marko.addEdge("knows", josh, T.id, 8, "weight", 1.0f);
   marko.addEdge("created", lop, T.id, 9, "weight", 0.4f);
   josh.addEdge("created", ripple, T.id, 10, "weight", 1.0f);
   josh.addEdge("created", lop, T.id, 11, "weight", 0.4f);
   peter.addEdge("created", lop, T.id, 12, "weight", 0.2f);
 }
  @Override
  public boolean remove(Object o) {
    maybeLoad();
    Vertex v;
    if (o instanceof UmlgNode) {
      UmlgNode node = (UmlgNode) o;
      v = node.getVertex();
      removeEdge(v);
    } else if (o.getClass().isEnum()) {
      v = removeFromInternalMap(o);
      removeEdge(v);
      v.remove();
    } else if (isOnePrimitive() || getDataTypeEnum() != null) {
      throw new IllegalStateException(
          "one primitive or data type can not have an association class.");
    } else {
      v = removeFromInternalMap(o);
      removeEdge(v);
      v.remove();
    }

    return super.remove(o);
  }
Exemplo n.º 13
0
 private static void createVertexProperty(
     final Graph graphToWriteTo,
     final Vertex v,
     final VertexProperty<Object> p,
     final boolean hidden) {
   final List<Object> propertyArgs = new ArrayList<>();
   if (graphToWriteTo.features().vertex().properties().supportsUserSuppliedIds())
     appendToArgList(propertyArgs, T.id, p.id());
   p.iterators()
       .propertyIterator()
       .forEachRemaining(it -> appendToArgList(propertyArgs, it.key(), it.value()));
   // p.iterators().hiddenPropertyIterator().forEachRemaining(it -> appendToArgList(propertyArgs,
   // Graph.Key.hide(it.key()), it.value()));
   v.property(hidden ? Graph.Key.hide(p.key()) : p.key(), p.value(), propertyArgs.toArray());
 }
  @Test
  public void shouldAppendPartitionToEdge() {
    final Vertex v1 = g.addVertex("any", "thing");
    final Vertex v2 = g.addVertex("some", "thing");
    final Edge e = v1.addEdge("connectsTo", v2, "every", "thing");

    assertNotNull(v1);
    assertEquals("thing", v1.property("any").value());
    assertEquals("A", v2.property(partition).value());

    assertNotNull(v2);
    assertEquals("thing", v2.property("some").value());
    assertEquals("A", v2.property(partition).value());

    assertNotNull(e);
    assertEquals("thing", e.property("every").value());
    assertEquals("connectsTo", e.label());
    assertEquals("A", e.property(partition).value());
  }
  @Test
  public void shouldWriteVerticesToMultiplePartitions() {
    final Vertex vA = g.addVertex("any", "a");
    final PartitionGraphStrategy strategy =
        (PartitionGraphStrategy) ((StrategyWrappedGraph) g).strategy().getGraphStrategy().get();
    strategy.setWritePartition("B");
    final Vertex vB = g.addVertex("any", "b");

    assertNotNull(vA);
    assertEquals("a", vA.property("any").value());
    assertEquals("A", vA.property(partition).value());

    assertNotNull(vB);
    assertEquals("b", vB.property("any").value());
    assertEquals("B", vB.property(partition).value());

    /* not applicable to SubgraphStrategy
    final GraphTraversal t = g.V();
    assertTrue(t.strategies().get().stream().anyMatch(o -> o.getClass().equals(PartitionGraphStrategy.PartitionGraphTraversalStrategy.class)));
    */

    g.V()
        .forEach(
            v -> {
              assertTrue(v instanceof StrategyWrappedVertex);
              assertEquals("a", v.property("any").value());
            });

    strategy.removeReadPartition("A");
    strategy.addReadPartition("B");

    g.V()
        .forEach(
            v -> {
              assertTrue(v instanceof StrategyWrappedVertex);
              assertEquals("b", v.property("any").value());
            });

    strategy.addReadPartition("A");
    assertEquals(new Long(2), g.V().count().next());
  }
  @Test
  public void shouldWriteToMultiplePartitions() {
    final Vertex vA = g.addVertex("any", "a");
    final Vertex vAA = g.addVertex("any", "aa");
    final Edge eAtoAA = vA.addEdge("a->a", vAA);

    final PartitionGraphStrategy strategy =
        (PartitionGraphStrategy) ((StrategyWrappedGraph) g).strategy().getGraphStrategy().get();
    strategy.setWritePartition("B");
    final Vertex vB = g.addVertex("any", "b");
    vA.addEdge("a->b", vB);

    strategy.setWritePartition("C");
    final Vertex vC = g.addVertex("any", "c");
    final Edge eBtovC = vB.addEdge("b->c", vC);
    final Edge eAtovC = vA.addEdge("a->c", vC);

    /* not applicable to SubgraphStrategy
    final GraphTraversal t = g.V();
    assertTrue(t.strategies().get().stream().anyMatch(o -> o.getClass().equals(PartitionGraphStrategy.PartitionGraphTraversalStrategy.class)));
    */

    strategy.clearReadPartitions();
    assertEquals(new Long(0), g.V().count().next());
    assertEquals(new Long(0), g.E().count().next());

    strategy.addReadPartition("A");
    assertEquals(new Long(2), g.V().count().next());
    assertEquals(new Long(1), g.E().count().next());
    assertEquals(new Long(1), g.v(vA.id()).outE().count().next());
    assertEquals(eAtoAA.id(), g.v(vA.id()).outE().next().id());
    assertEquals(new Long(1), g.v(vA.id()).out().count().next());
    assertEquals(vAA.id(), g.v(vA.id()).out().next().id());

    strategy.addReadPartition("B");
    assertEquals(new Long(3), g.V().count().next());
    assertEquals(new Long(2), g.E().count().next());

    strategy.addReadPartition("C");
    assertEquals(new Long(4), g.V().count().next());
    assertEquals(new Long(4), g.E().count().next());

    strategy.removeReadPartition("A");
    strategy.removeReadPartition("B");

    assertEquals(new Long(1), g.V().count().next());
    // two edges are in the "C" partition, but one each of their incident vertices are not
    assertEquals(new Long(0), g.E().count().next());

    assertEquals(new Long(0), g.v(vC.id()).inE().count().next());
    assertEquals(new Long(0), g.v(vC.id()).in().count().next());

    strategy.addReadPartition("B");
    // only one edge in, due to excluded vertices; vA is not in {B,C}
    assertEquals(new Long(1), g.v(vC.id()).inE().count().next());
    assertEquals(new Long(1), g.v(vC.id()).in().count().next());
    assertEquals(vC.id(), g.e(eBtovC.id()).inV().id().next());
    assertEquals(vB.id(), g.e(eBtovC.id()).outV().id().next());
    assertEquals(vC.id(), g.e(eAtovC.id()).inV().id().next());
    assertFalse(g.e(eAtovC.id()).outV().hasNext());

    /* not applicable to SubgraphStrategy
    strategy.addReadPartition("A");
    g.v(vA.id()).out().out().forEach(v -> {
        assertTrue(v instanceof StrategyWrapped);
        assertFalse(((StrategyWrappedElement) v).getBaseElement() instanceof StrategyWrapped);
    });

    g.v(vA.id()).outE().inV().outE().forEach(e -> {
        assertTrue(e instanceof StrategyWrapped);
        assertFalse(((StrategyWrappedElement) e).getBaseElement() instanceof StrategyWrapped);
    });
    */
  }