/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.tinkerpop.gremlin.process.traversal.dsl.graph;
import org.apache.commons.configuration.Configuration;
import org.apache.tinkerpop.gremlin.process.computer.Computer;
import org.apache.tinkerpop.gremlin.process.computer.GraphComputer;
import org.apache.tinkerpop.gremlin.process.remote.RemoteConnection;
import org.apache.tinkerpop.gremlin.process.remote.traversal.strategy.decoration.RemoteStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.Bindings;
import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalSource;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.engine.ComputerTraversalEngine;
import org.apache.tinkerpop.gremlin.process.traversal.engine.StandardTraversalEngine;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddVertexStartStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.InjectStep;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.RequirementsStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
import org.apache.tinkerpop.gremlin.structure.Edge;
import org.apache.tinkerpop.gremlin.structure.Graph;
import org.apache.tinkerpop.gremlin.structure.T;
import org.apache.tinkerpop.gremlin.structure.Transaction;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.apache.tinkerpop.gremlin.structure.util.StringFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.function.BinaryOperator;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
/**
* A {@code GraphTraversalSource} is the primary DSL of the Gremlin traversal machine.
* It provides access to all the configurations and steps for Turing complete graph computing.
* Any DSL can be constructed based on the methods of both {@code GraphTraversalSource} and {@link GraphTraversal}.
*
* @author Marko A. Rodriguez (http://markorodriguez.com)
*/
public class GraphTraversalSource implements TraversalSource {
protected transient RemoteConnection connection;
protected final Graph graph;
protected TraversalStrategies strategies;
protected Bytecode bytecode = new Bytecode();
////////////////
public static final class Symbols {
private Symbols() {
// static fields only
}
public static final String withBulk = "withBulk";
public static final String withPath = "withPath";
}
////////////////
@Override
public Optional<Class> getAnonymousTraversalClass() {
return Optional.of(__.class);
}
public GraphTraversalSource(final Graph graph, final TraversalStrategies traversalStrategies) {
this.graph = graph;
this.strategies = traversalStrategies;
}
public GraphTraversalSource(final Graph graph) {
this(graph, TraversalStrategies.GlobalCache.getStrategies(graph.getClass()));
}
@Override
public TraversalStrategies getStrategies() {
return this.strategies;
}
@Override
public Graph getGraph() {
return this.graph;
}
@Override
public Bytecode getBytecode() {
return this.bytecode;
}
@SuppressWarnings("CloneDoesntDeclareCloneNotSupportedException")
public GraphTraversalSource clone() {
try {
final GraphTraversalSource clone = (GraphTraversalSource) super.clone();
clone.strategies = this.strategies.clone();
clone.bytecode = this.bytecode.clone();
return clone;
} catch (final CloneNotSupportedException e) {
throw new IllegalStateException(e.getMessage(), e);
}
}
//// CONFIGURATIONS
@Override
public GraphTraversalSource withStrategies(final TraversalStrategy... traversalStrategies) {
return (GraphTraversalSource) TraversalSource.super.withStrategies(traversalStrategies);
}
@Override
@SuppressWarnings({"unchecked"})
public GraphTraversalSource withoutStrategies(final Class<? extends TraversalStrategy>... traversalStrategyClasses) {
return (GraphTraversalSource) TraversalSource.super.withoutStrategies(traversalStrategyClasses);
}
@Override
@Deprecated
public GraphTraversalSource withBindings(final Bindings bindings) {
return (GraphTraversalSource) TraversalSource.super.withBindings(bindings);
}
@Override
public GraphTraversalSource withComputer(final Computer computer) {
return (GraphTraversalSource) TraversalSource.super.withComputer(computer);
}
@Override
public GraphTraversalSource withComputer(final Class<? extends GraphComputer> graphComputerClass) {
return (GraphTraversalSource) TraversalSource.super.withComputer(graphComputerClass);
}
@Override
public GraphTraversalSource withComputer() {
return (GraphTraversalSource) TraversalSource.super.withComputer();
}
@Override
public <A> GraphTraversalSource withSideEffect(final String key, final Supplier<A> initialValue, final BinaryOperator<A> reducer) {
return (GraphTraversalSource) TraversalSource.super.withSideEffect(key, initialValue, reducer);
}
@Override
public <A> GraphTraversalSource withSideEffect(final String key, final A initialValue, final BinaryOperator<A> reducer) {
return (GraphTraversalSource) TraversalSource.super.withSideEffect(key, initialValue, reducer);
}
@Override
public <A> GraphTraversalSource withSideEffect(final String key, final A initialValue) {
return (GraphTraversalSource) TraversalSource.super.withSideEffect(key, initialValue);
}
@Override
public <A> GraphTraversalSource withSideEffect(final String key, final Supplier<A> initialValue) {
return (GraphTraversalSource) TraversalSource.super.withSideEffect(key, initialValue);
}
@Override
public <A> GraphTraversalSource withSack(final Supplier<A> initialValue, final UnaryOperator<A> splitOperator, final BinaryOperator<A> mergeOperator) {
return (GraphTraversalSource) TraversalSource.super.withSack(initialValue, splitOperator, mergeOperator);
}
@Override
public <A> GraphTraversalSource withSack(final A initialValue, final UnaryOperator<A> splitOperator, final BinaryOperator<A> mergeOperator) {
return (GraphTraversalSource) TraversalSource.super.withSack(initialValue, splitOperator, mergeOperator);
}
@Override
public <A> GraphTraversalSource withSack(final A initialValue) {
return (GraphTraversalSource) TraversalSource.super.withSack(initialValue);
}
@Override
public <A> GraphTraversalSource withSack(final Supplier<A> initialValue) {
return (GraphTraversalSource) TraversalSource.super.withSack(initialValue);
}
@Override
public <A> GraphTraversalSource withSack(final Supplier<A> initialValue, final UnaryOperator<A> splitOperator) {
return (GraphTraversalSource) TraversalSource.super.withSack(initialValue, splitOperator);
}
@Override
public <A> GraphTraversalSource withSack(final A initialValue, final UnaryOperator<A> splitOperator) {
return (GraphTraversalSource) TraversalSource.super.withSack(initialValue, splitOperator);
}
@Override
public <A> GraphTraversalSource withSack(final Supplier<A> initialValue, final BinaryOperator<A> mergeOperator) {
return (GraphTraversalSource) TraversalSource.super.withSack(initialValue, mergeOperator);
}
@Override
public <A> GraphTraversalSource withSack(final A initialValue, final BinaryOperator<A> mergeOperator) {
return (GraphTraversalSource) TraversalSource.super.withSack(initialValue, mergeOperator);
}
public GraphTraversalSource withBulk(final boolean useBulk) {
if (useBulk)
return this;
final GraphTraversalSource clone = this.clone();
RequirementsStrategy.addRequirements(clone.getStrategies(), TraverserRequirement.ONE_BULK);
clone.bytecode.addSource(Symbols.withBulk, useBulk);
return clone;
}
public GraphTraversalSource withPath() {
final GraphTraversalSource clone = this.clone();
RequirementsStrategy.addRequirements(clone.getStrategies(), TraverserRequirement.PATH);
clone.bytecode.addSource(Symbols.withPath);
return clone;
}
@Override
public GraphTraversalSource withRemote(final Configuration conf) {
return (GraphTraversalSource) TraversalSource.super.withRemote(conf);
}
@Override
public GraphTraversalSource withRemote(final String configFile) throws Exception {
return (GraphTraversalSource) TraversalSource.super.withRemote(configFile);
}
@Override
public GraphTraversalSource withRemote(final RemoteConnection connection) {
try {
// check if someone called withRemote() more than once, so just release resources on the initial
// connection as you can't have more than one. maybe better to toss IllegalStateException??
if (this.connection != null)
this.connection.close();
} catch (Exception ignored) {
// not sure there's anything to do here
}
this.connection = connection;
final TraversalSource clone = this.clone();
clone.getStrategies().addStrategies(new RemoteStrategy(connection));
return (GraphTraversalSource) clone;
}
//// SPAWNS
/**
* @deprecated As of release 3.1.0, replaced by {@link #addV()}
*/
@Deprecated
public GraphTraversal<Vertex, Vertex> addV(final Object... keyValues) {
if (keyValues.length != 0 && keyValues[0].equals(T.label)) {
final GraphTraversal<Vertex, Vertex> traversal = this.addV(keyValues[1].toString());
this.addV(keyValues[1].toString());
for (int i = 2; i < keyValues.length; i = i + 2) {
traversal.property(keyValues[i], keyValues[i + 1]);
}
return traversal;
} else {
final GraphTraversal<Vertex, Vertex> traversal = this.addV();
this.addV(keyValues[1].toString());
for (int i = 0; i < keyValues.length; i = i + 2) {
traversal.property(keyValues[i], keyValues[i + 1]);
}
return traversal;
}
}
public GraphTraversal<Vertex, Vertex> addV(final String label) {
final GraphTraversalSource clone = this.clone();
clone.bytecode.addStep(GraphTraversal.Symbols.addV, label);
final GraphTraversal.Admin<Vertex, Vertex> traversal = new DefaultGraphTraversal<>(clone);
return traversal.addStep(new AddVertexStartStep(traversal, label));
}
public GraphTraversal<Vertex, Vertex> addV() {
final GraphTraversalSource clone = this.clone();
clone.bytecode.addStep(GraphTraversal.Symbols.addV);
final GraphTraversal.Admin<Vertex, Vertex> traversal = new DefaultGraphTraversal<>(clone);
return traversal.addStep(new AddVertexStartStep(traversal, null));
}
public <S> GraphTraversal<S, S> inject(S... starts) {
final GraphTraversalSource clone = this.clone();
clone.bytecode.addStep(GraphTraversal.Symbols.inject, starts);
final GraphTraversal.Admin<S, S> traversal = new DefaultGraphTraversal<>(clone);
return traversal.addStep(new InjectStep<S>(traversal, starts));
}
public GraphTraversal<Vertex, Vertex> V(final Object... vertexIds) {
final GraphTraversalSource clone = this.clone();
clone.bytecode.addStep(GraphTraversal.Symbols.V, vertexIds);
final GraphTraversal.Admin<Vertex, Vertex> traversal = new DefaultGraphTraversal<>(clone);
return traversal.addStep(new GraphStep<>(traversal, Vertex.class, true, vertexIds));
}
public GraphTraversal<Edge, Edge> E(final Object... edgesIds) {
final GraphTraversalSource clone = this.clone();
clone.bytecode.addStep(GraphTraversal.Symbols.E, edgesIds);
final GraphTraversal.Admin<Edge, Edge> traversal = new DefaultGraphTraversal<>(clone);
return traversal.addStep(new GraphStep<>(traversal, Edge.class, true, edgesIds));
}
public Transaction tx() {
return this.graph.tx();
}
@Override
public void close() throws Exception {
if (connection != null) connection.close();
}
@Override
public String toString() {
return StringFactory.traversalSourceString(this);
}
//////////////////
// DEPRECATION //
/////////////////
/**
* @deprecated As of release 3.2.0. Please use {@link Graph#traversal(Class)}.
*/
@Deprecated
public static Builder build() {
return new Builder();
}
/**
* @deprecated As of release 3.2.0. Please use {@link Graph#traversal(Class)}.
*/
@Deprecated
public static Builder standard() {
return GraphTraversalSource.build().engine(StandardTraversalEngine.build());
}
/**
* @deprecated As of release 3.2.0. Please use {@link Graph#traversal(Class)}.
*/
@Deprecated
public static Builder computer() {
return GraphTraversalSource.build().engine(ComputerTraversalEngine.build());
}
/**
* @deprecated As of release 3.2.0. Please use {@link Graph#traversal(Class)}.
*/
@Deprecated
public static Builder computer(final Class<? extends GraphComputer> graphComputerClass) {
return GraphTraversalSource.build().engine(ComputerTraversalEngine.build().computer(graphComputerClass));
}
/**
* @deprecated As of release 3.2.0. Please use {@link Graph#traversal(Class)}.
*/
@Deprecated
public final static class Builder implements TraversalSource.Builder<GraphTraversalSource> {
private TraversalEngine.Builder engineBuilder = StandardTraversalEngine.build();
private List<TraversalStrategy> withStrategies = new ArrayList<>();
private List<Class<? extends TraversalStrategy>> withoutStrategies = new ArrayList<>();
private Builder() {
}
/**
* @deprecated As of release 3.2.0. Please use {@link Graph#traversal(Class)}.
*/
@Deprecated
@Override
public Builder engine(final TraversalEngine.Builder engineBuilder) {
this.engineBuilder = engineBuilder;
return this;
}
/**
* @deprecated As of release 3.2.0. Please use {@link Graph#traversal(Class)}.
*/
@Deprecated
@Override
public Builder with(final TraversalStrategy strategy) {
this.withStrategies.add(strategy);
return this;
}
/**
* @deprecated As of release 3.2.0. Please use {@link Graph#traversal(Class)}.
*/
@Deprecated
@Override
public TraversalSource.Builder without(final Class<? extends TraversalStrategy> strategyClass) {
this.withoutStrategies.add(strategyClass);
return this;
}
/**
* @deprecated As of release 3.2.0. Please use {@link Graph#traversal(Class)}.
*/
@Deprecated
@Override
public GraphTraversalSource create(final Graph graph) {
GraphTraversalSource traversalSource = new GraphTraversalSource(graph);
if (!this.withStrategies.isEmpty())
traversalSource = traversalSource.withStrategies(this.withStrategies.toArray(new TraversalStrategy[this.withStrategies.size()]));
if (!this.withoutStrategies.isEmpty())
traversalSource = traversalSource.withoutStrategies(this.withoutStrategies.toArray(new Class[this.withoutStrategies.size()]));
if (this.engineBuilder instanceof ComputerTraversalEngine.Builder)
traversalSource = (GraphTraversalSource) ((ComputerTraversalEngine.Builder) this.engineBuilder).create(traversalSource);
return traversalSource;
}
}
}