org.apache.tinkerpop.gremlin.process.computer.VertexComputeKey Java Examples

public TinkerGraphComputerView(final TinkerGraph graph, final GraphFilter graphFilter, final Set<VertexComputeKey> computeKeys) {
    this.graph = graph;
    this.computeKeys = new HashMap<>();
    computeKeys.forEach(key -> this.computeKeys.put(key.getKey(), key));
    this.computeProperties = new ConcurrentHashMap<>();
    this.graphFilter = graphFilter;
    if (this.graphFilter.hasFilter()) {
        graph.vertices().forEachRemaining(vertex -> {
            boolean legalVertex = false;
            if (this.graphFilter.hasVertexFilter() && this.graphFilter.legalVertex(vertex)) {
                this.legalVertices.add(vertex.id());
                legalVertex = true;
            }
            if ((legalVertex || !this.graphFilter.hasVertexFilter()) && this.graphFilter.hasEdgeFilter()) {
                final Set<Object> edges = new HashSet<>();
                this.legalEdges.put(vertex.id(), edges);
                this.graphFilter.legalEdges(vertex).forEachRemaining(edge -> edges.add(edge.id()));
            }
        });
    }
}
 

public static <M> JavaPairRDD<Object, VertexWritable> prepareFinalGraphRDD(
        final JavaPairRDD<Object, VertexWritable> graphRDD,
        final JavaPairRDD<Object, ViewIncomingPayload<M>> viewIncomingRDD,
        final Set<VertexComputeKey> vertexComputeKeys) {
    // the graphRDD and the viewRDD must have the same partitioner
    if (graphRDD.partitioner().isPresent())
        assert (graphRDD.partitioner().get().equals(viewIncomingRDD.partitioner().get()));
    final String[] vertexComputeKeysArray = VertexProgramHelper.vertexComputeKeysAsArray(vertexComputeKeys); // the compute keys as an array
    return graphRDD.leftOuterJoin(viewIncomingRDD)
            .mapValues(tuple -> {
                final StarGraph.StarVertex vertex = tuple._1().get();
                vertex.dropVertexProperties(vertexComputeKeysArray); // drop all existing compute keys
                // attach the final computed view to the cached graph
                final List<DetachedVertexProperty<Object>> view = tuple._2().isPresent() ? tuple._2().get().getView() : Collections.emptyList();
                for (final DetachedVertexProperty<Object> property : view) {
                    if (!VertexProgramHelper.isTransientVertexComputeKey(property.key(), vertexComputeKeys))
                        property.attach(Attachable.Method.create(vertex));
                }
                return tuple._1();
            });
}
 

public TinkerGraphComputerView(final TinkerGraph graph, final GraphFilter graphFilter, final Set<VertexComputeKey> computeKeys) {
    this.graph = graph;
    this.computeKeys = new HashMap<>();
    computeKeys.forEach(key -> this.computeKeys.put(key.getKey(), key));
    this.computeProperties = new ConcurrentHashMap<>();
    this.graphFilter = graphFilter;
    if (this.graphFilter.hasFilter()) {
        graph.vertices().forEachRemaining(vertex -> {
            boolean legalVertex = false;
            if (this.graphFilter.hasVertexFilter() && this.graphFilter.legalVertex(vertex)) {
                this.legalVertices.add(vertex.id());
                legalVertex = true;
            }
            if ((legalVertex || !this.graphFilter.hasVertexFilter()) && this.graphFilter.hasEdgeFilter()) {
                final Set<Object> edges = new HashSet<>();
                this.legalEdges.put(vertex.id(), edges);
                this.graphFilter.legalEdges(vertex).forEachRemaining(edge -> edges.add(edge.id()));
            }
        });
    }
}
 

@Override
public void loadState(final Graph graph, final Configuration configuration) {
    if (configuration.containsKey(INITIAL_RANK_TRAVERSAL))
        this.initialRankTraversal = PureTraversal.loadState(configuration, INITIAL_RANK_TRAVERSAL, graph);
    if (configuration.containsKey(EDGE_TRAVERSAL)) {
        this.edgeTraversal = PureTraversal.loadState(configuration, EDGE_TRAVERSAL, graph);
        this.incidentMessageScope = MessageScope.Local.of(() -> this.edgeTraversal.get().clone());
        this.countMessageScope = MessageScope.Local.of(new MessageScope.Local.ReverseTraversalSupplier(this.incidentMessageScope));
    }
    this.alpha = configuration.getDouble(ALPHA, this.alpha);
    this.epsilon = configuration.getDouble(EPSILON, this.epsilon);
    this.maxIterations = configuration.getInt(MAX_ITERATIONS, 20);
    this.property = configuration.getString(PROPERTY, PAGE_RANK);
    this.vertexComputeKeys = new HashSet<>(Arrays.asList(
            VertexComputeKey.of(this.property, false),
            VertexComputeKey.of(EDGE_COUNT, true)));
    this.memoryComputeKeys = new HashSet<>(Arrays.asList(
            MemoryComputeKey.of(TELEPORTATION_ENERGY, Operator.sum, true, true),
            MemoryComputeKey.of(VERTEX_COUNT, Operator.sum, true, true),
            MemoryComputeKey.of(CONVERGENCE_ERROR, Operator.sum, false, true)));
}
 

public static <M> JavaPairRDD<Object, VertexWritable> prepareFinalGraphRDD(
        final JavaPairRDD<Object, VertexWritable> graphRDD,
        final JavaPairRDD<Object, ViewIncomingPayload<M>> viewIncomingRDD,
        final Set<VertexComputeKey> vertexComputeKeys) {
    // the graphRDD and the viewRDD must have the same partitioner
    Preconditions.checkState(!graphRDD.partitioner().isPresent() || (graphRDD.partitioner().get().equals(viewIncomingRDD.partitioner().get())));
    final String[] vertexComputeKeysArray = VertexProgramHelper.vertexComputeKeysAsArray(vertexComputeKeys); // the compute keys as an array
    return graphRDD.leftOuterJoin(viewIncomingRDD)
            .mapValues(tuple -> {
                final StarGraph.StarVertex vertex = tuple._1().get();
                vertex.dropVertexProperties(vertexComputeKeysArray); // drop all existing compute keys
                // attach the final computed view to the cached graph
                final List<DetachedVertexProperty<Object>> view = tuple._2().isPresent() ? tuple._2().get().getView() : Collections.emptyList();
                for (final DetachedVertexProperty<Object> property : view) {
                    if (!VertexProgramHelper.isTransientVertexComputeKey(property.key(), vertexComputeKeys)){
                        property.attach(Attachable.Method.create(vertex));}
                }
                return tuple._1();
            });
}
 

protected void complete() {
    // remove all transient properties from the vertices
    for (final VertexComputeKey computeKey : this.computeKeys.values()) {
        if (computeKey.isTransient()) {
            for (final Map<String, List<VertexProperty<?>>> properties : this.computeProperties.values()) {
                properties.remove(computeKey.getKey());
            }
        }
    }
}
 

protected void complete() {
    // remove all transient properties from the vertices
    for (final VertexComputeKey computeKey : this.computeKeys.values()) {
        if (computeKey.isTransient()) {
            for (final Map<String, List<VertexProperty<?>>> properties : this.computeProperties.values()) {
                properties.remove(computeKey.getKey());
            }
        }
    }
}
 

@Override
public Set<VertexComputeKey> getVertexComputeKeys() {
    return new HashSet<>(Arrays.asList(
            VertexComputeKey.of(shortestPathRecordedAndBroadcasted, true),
            VertexComputeKey.of(pathFoundButIsNotTheShortest, true),
            VertexComputeKey.of(srcMsgFromPrevIterations, true),
            VertexComputeKey.of(destMsgFromPrevIterations, true)
    ));
}
 

public static boolean isTransientVertexComputeKey(final String key, final Set<VertexComputeKey> vertexComputeKeySet) {
    for (final VertexComputeKey vertexComputeKey : vertexComputeKeySet) {
        if (vertexComputeKey.getKey().equals(key))
            return vertexComputeKey.isTransient();
    }
    throw new IllegalArgumentException("Could not find key in vertex compute key set: " + key);
}
 

public static Set<String> vertexComputeKeysAsSet(final Set<VertexComputeKey> vertexComputeKeySet) {
    final Set<String> set = new HashSet<>(vertexComputeKeySet.size());
    for (final VertexComputeKey key : vertexComputeKeySet) {
        set.add(key.getKey());
    }
    return set;
}
 

@Override
public Set<VertexComputeKey> getVertexComputeKeys() {
    return VERTEX_COMPUTE_KEYS;
}
 

public static TinkerGraphComputerView createGraphComputerView(final TinkerGraph graph, final GraphFilter graphFilter, final Set<VertexComputeKey> computeKeys) {
    return graph.graphComputerView = new TinkerGraphComputerView(graph, graphFilter, computeKeys);
}
 

public static TinkerGraphComputerView createGraphComputerView(final TinkerGraph graph, final GraphFilter graphFilter, final Set<VertexComputeKey> computeKeys) {
    return graph.graphComputerView = new TinkerGraphComputerView(graph, graphFilter, computeKeys);
}
 

@Override
public Set<VertexComputeKey> getVertexComputeKeys() {
    return Collections.singleton(VertexComputeKey.of(TraversalVertexProgram.HALTED_TRAVERSERS, false));
}
 

private ComputerGraph(final State state, final Vertex starVertex, final Optional<VertexProgram<?>> vertexProgram) {
    this.state = state;
    this.computeKeys = vertexProgram.isPresent() ? vertexProgram.get().getVertexComputeKeys().stream().map(VertexComputeKey::getKey).collect(Collectors.toSet()) : Collections.emptySet();
    this.starVertex = new ComputerVertex(starVertex);
}
 

public static String[] vertexComputeKeysAsArray(final Set<VertexComputeKey> vertexComputeKeySet) {
    return VertexProgramHelper.vertexComputeKeysAsSet(vertexComputeKeySet).toArray(new String[vertexComputeKeySet.size()]);
}
 

@Override
public Set<VertexComputeKey> getVertexComputeKeys() {
    return VERTEX_COMPUTE_KEYS;
}
 

@Override
public Set<VertexComputeKey> getVertexComputeKeys() {
    return Sets.newHashSet(
            VertexComputeKey.of(DEGREE, true),
            VertexComputeKey.of(LABEL, true));
}
 

@Override
public Set<VertexComputeKey> getVertexComputeKeys() {
    return new HashSet<>(Arrays.asList(VertexComputeKey.of(this.property, false), VertexComputeKey.of(VOTE_STRENGTH, true)));
}
 

@Override
public Set<VertexComputeKey> getVertexComputeKeys() {
    return new HashSet<>(Arrays.asList(
            VertexComputeKey.of(property, false),
            VertexComputeKey.of(TraversalVertexProgram.HALTED_TRAVERSERS, false)));
}
 

@Override
public Set<VertexComputeKey> getVertexComputeKeys() {
    return this.vertexComputeKeys;
}
 

@Override
public Set<VertexComputeKey> getVertexComputeKeys() {
    return Collections.singleton(VertexComputeKey.of(CLUSTER_LABEL, false));
}
 

@Override
public Set<VertexComputeKey> getVertexComputeKeys() {
    return Collections.singleton(VertexComputeKey.of(EDGE_COUNT, false));
}
 

@Override
public Set<VertexComputeKey> getVertexComputeKeys() {
    return Collections.singleton(VertexComputeKey.of(CLUSTER_LABEL, false));
}
 

@Override
public Set<VertexComputeKey> getVertexComputeKeys() {
    return Collections.singleton(VertexComputeKey.of(DEGREE, false));
}
 

@Override
public Set<VertexComputeKey> getVertexComputeKeys() {
    return VERTEX_COMPUTE_KEYS;
}
 

@Override
public Set<VertexComputeKey> getVertexComputeKeys() {
    return VERTEX_COMPUTE_KEYS;
}