You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by sp...@apache.org on 2016/01/12 21:28:06 UTC
[1/2] incubator-tinkerpop git commit: Set javadoc generation to quiet.
Repository: incubator-tinkerpop
Updated Branches:
refs/heads/master ef40dce31 -> 9cf6b485a
Set javadoc generation to quiet.
Get rid of some superfluous informational messages to further reduce the log sizes.
Project: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/commit/e6a05610
Tree: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/tree/e6a05610
Diff: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/diff/e6a05610
Branch: refs/heads/master
Commit: e6a0561002c0b2dab2323713b2b150482676ceca
Parents: ef40dce
Author: Stephen Mallette <sp...@genoprime.com>
Authored: Tue Jan 12 15:12:59 2016 -0500
Committer: Stephen Mallette <sp...@genoprime.com>
Committed: Tue Jan 12 15:12:59 2016 -0500
----------------------------------------------------------------------
pom.xml | 3 +++
1 file changed, 3 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/e6a05610/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index 405d03e..f669b7c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -211,6 +211,7 @@ limitations under the License.
<dependencySourceInclude>org.apache.tinkerpop:*</dependencySourceInclude>
</dependencySourceIncludes>
<overview>${basedir}/docs/javadoc/overview.html</overview>
+ <quiet>true</quiet>
</configuration>
</execution>
<execution>
@@ -435,6 +436,7 @@ limitations under the License.
<dependencySourceInclude>org.apache.tinkerpop:*</dependencySourceInclude>
</dependencySourceIncludes>
<overview>${basedir}/docs/javadoc/overview.html</overview>
+ <quiet>true</quiet>
</configuration>
<reports>
<report>javadoc</report>
@@ -449,6 +451,7 @@ limitations under the License.
<dependencySourceInclude>org.apache.tinkerpop:*</dependencySourceInclude>
</dependencySourceIncludes>
<overview>${basedir}/docs/javadoc/overview.html</overview>
+ <quiet>true</quiet>
</configuration>
<reports>
<report>aggregate</report>
[2/2] incubator-tinkerpop git commit: Fixed a number of javadoc
warnings around anonymous traversal.
Posted by sp...@apache.org.
Fixed a number of javadoc warnings around anonymous traversal.
Project: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/commit/9cf6b485
Tree: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/tree/9cf6b485
Diff: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/diff/9cf6b485
Branch: refs/heads/master
Commit: 9cf6b485ab786bbfbcb3c04a6863307d1b98f31e
Parents: e6a0561
Author: Stephen Mallette <sp...@genoprime.com>
Authored: Tue Jan 12 15:27:36 2016 -0500
Committer: Stephen Mallette <sp...@genoprime.com>
Committed: Tue Jan 12 15:27:36 2016 -0500
----------------------------------------------------------------------
.../gremlin/process/traversal/dsl/graph/__.java | 356 +++++++++++++++----
1 file changed, 293 insertions(+), 63 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/9cf6b485/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java
index ff0a9a5..53d9a62 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java
@@ -44,6 +44,8 @@ import java.util.function.Function;
import java.util.function.Predicate;
/**
+ * An anonymous {@link GraphTraversal}.
+ *
* @author Marko A. Rodriguez (http://markorodriguez.com)
*/
public class __ {
@@ -64,208 +66,217 @@ public class __ {
///////////////////// MAP STEPS /////////////////////
/**
- * @see {@link GraphTraversal#map(Function)}.
+ * @see GraphTraversal#map(Function)
*/
public static <A, B> GraphTraversal<A, B> map(final Function<Traverser<A>, B> function) {
return __.<A>start().map(function);
}
+ /**
+ * @see GraphTraversal#map(Traversal)
+ */
public static <A, B> GraphTraversal<A, B> map(final Traversal<?, B> mapTraversal) {
return __.<A>start().map(mapTraversal);
}
/**
- * @see {@link GraphTraversal#flatMap(Function)}.
+ * @see GraphTraversal#flatMap(Function)
*/
public static <A, B> GraphTraversal<A, B> flatMap(final Function<Traverser<A>, Iterator<B>> function) {
return __.<A>start().flatMap(function);
}
+ /**
+ * @see GraphTraversal#flatMap(Traversal)
+ */
public static <A, B> GraphTraversal<A, B> flatMap(final Traversal<?, B> flatMapTraversal) {
return __.<A>start().flatMap(flatMapTraversal);
}
/**
- * @see {@link GraphTraversal#identity()}
+ * @see GraphTraversal#identity()
*/
public static <A> GraphTraversal<A, A> identity() {
return __.<A>start().identity();
}
/**
- * @see {@link GraphTraversal#constant(Object)}
+ * @see GraphTraversal#constant(Object)
*/
public static <A> GraphTraversal<A, A> constant(final A a) {
return __.<A>start().constant(a);
}
/**
- * @see {@link GraphTraversal#label()}
+ * @see GraphTraversal#label()
*/
public static <A> GraphTraversal<A, String> label() {
return __.<A>start().label();
}
/**
- * @see {@link GraphTraversal#id()}
+ * @see GraphTraversal#id()
*/
public static <A> GraphTraversal<A, Object> id() {
return __.<A>start().id();
}
/**
- * @see {@link GraphTraversal#V(Object...)}
+ * @see GraphTraversal#V(Object...)
*/
public static <A> GraphTraversal<A, Vertex> V(final Object... vertexIdsOrElements) {
return __.<A>start().V(vertexIdsOrElements);
}
/**
- * @see {@link GraphTraversal#to(Direction, String...)}
+ * @see GraphTraversal#to(Direction, String...)
*/
public static <A> GraphTraversal<A, Vertex> to(final Direction direction, final String... edgeLabels) {
return __.<A>start().to(direction, edgeLabels);
}
/**
- * @see {@link GraphTraversal#out(String...)}
+ * @see GraphTraversal#out(String...)
*/
public static <A> GraphTraversal<A, Vertex> out(final String... edgeLabels) {
return __.<A>start().out(edgeLabels);
}
/**
- * @see {@link GraphTraversal#in(String...)}
+ * @see GraphTraversal#in(String...)
*/
public static <A> GraphTraversal<A, Vertex> in(final String... edgeLabels) {
return __.<A>start().in(edgeLabels);
}
/**
- * @see {@link GraphTraversal#both(String...)}
+ * @see GraphTraversal#both(String...)
*/
public static <A> GraphTraversal<A, Vertex> both(final String... edgeLabels) {
return __.<A>start().both(edgeLabels);
}
/**
- * @see {@link GraphTraversal#toE(Direction, String...)}
+ * @see GraphTraversal#toE(Direction, String...)
*/
public static <A> GraphTraversal<A, Edge> toE(final Direction direction, final String... edgeLabels) {
return __.<A>start().toE(direction, edgeLabels);
}
/**
- * @see {@link GraphTraversal#outE(String...)}
+ * @see GraphTraversal#outE(String...)
*/
public static <A> GraphTraversal<A, Edge> outE(final String... edgeLabels) {
return __.<A>start().outE(edgeLabels);
}
/**
- * @see {@link GraphTraversal#inE(String...)}
+ * @see GraphTraversal#inE(String...)
*/
public static <A> GraphTraversal<A, Edge> inE(final String... edgeLabels) {
return __.<A>start().inE(edgeLabels);
}
/**
- * @see {@link GraphTraversal#bothE(String...)}
+ * @see GraphTraversal#bothE(String...)
*/
public static <A> GraphTraversal<A, Edge> bothE(final String... edgeLabels) {
return __.<A>start().bothE(edgeLabels);
}
/**
- * @see {@link GraphTraversal#toV(Direction)}
+ * @see GraphTraversal#toV(Direction)
*/
public static <A> GraphTraversal<A, Vertex> toV(final Direction direction) {
return __.<A>start().toV(direction);
}
/**
- * @see {@link GraphTraversal#inV()}
+ * @see GraphTraversal#inV()
*/
public static <A> GraphTraversal<A, Vertex> inV() {
return __.<A>start().inV();
}
/**
- * @see {@link GraphTraversal#outV()}
+ * @see GraphTraversal#outV()
*/
public static <A> GraphTraversal<A, Vertex> outV() {
return __.<A>start().outV();
}
/**
- * @see {@link GraphTraversal#bothV()}
+ * @see GraphTraversal#bothV()
*/
public static <A> GraphTraversal<A, Vertex> bothV() {
return __.<A>start().bothV();
}
/**
- * @see {@link GraphTraversal#otherV()}
+ * @see GraphTraversal#otherV()
*/
public static <A> GraphTraversal<A, Vertex> otherV() {
return __.<A>start().otherV();
}
/**
- * @see {@link GraphTraversal#order()}
+ * @see GraphTraversal#order()
*/
public static <A> GraphTraversal<A, A> order() {
return __.<A>start().order();
}
/**
- * @see {@link GraphTraversal#order(Scope)}
+ * @see GraphTraversal#order(Scope)
*/
public static <A> GraphTraversal<A, A> order(final Scope scope) {
return __.<A>start().order(scope);
}
/**
- * @see {@link GraphTraversal#properties(String...)}
+ * @see GraphTraversal#properties(String...)
*/
public static <A, B> GraphTraversal<A, ? extends Property<B>> properties(final String... propertyKeys) {
return __.<A>start().properties(propertyKeys);
}
/**
- * @see {@link GraphTraversal#values(String...)}
+ * @see GraphTraversal#values(String...)
*/
public static <A, B> GraphTraversal<A, B> values(final String... propertyKeys) {
return __.<A>start().values(propertyKeys);
}
/**
- * @see {@link GraphTraversal#propertyMap(String...)}
+ * @see GraphTraversal#propertyMap(String...)
*/
public static <A, B> GraphTraversal<A, Map<String, B>> propertyMap(final String... propertyKeys) {
return __.<A>start().propertyMap(propertyKeys);
}
/**
- * @see {@link GraphTraversal#valueMap(String...)}
+ * @see GraphTraversal#valueMap(String...)
*/
public static <A, B> GraphTraversal<A, Map<String, B>> valueMap(final String... propertyKeys) {
return __.<A>start().valueMap(propertyKeys);
}
/**
- * @see {@link GraphTraversal#valueMap(boolean, String...)}
+ * @see GraphTraversal#valueMap(boolean, String...)
*/
public static <A, B> GraphTraversal<A, Map<String, B>> valueMap(final boolean includeTokens, final String... propertyKeys) {
return __.<A>start().valueMap(includeTokens, propertyKeys);
}
+ /**
+ * @see GraphTraversal#select(Column)
+ */
public static <A, B> GraphTraversal<A, Collection<B>> select(final Column column) {
return __.<A>start().select(column);
}
/**
- * @see {@link GraphTraversal#mapValues()}
+ * @see GraphTraversal#mapValues()
*/
@Deprecated
public static <A, B> GraphTraversal<A, B> mapValues() {
@@ -273,7 +284,7 @@ public class __ {
}
/**
- * @see {@link GraphTraversal#mapKeys()}
+ * @see GraphTraversal#mapKeys()
*/
@Deprecated
public static <A, B> GraphTraversal<A, B> mapKeys() {
@@ -281,175 +292,175 @@ public class __ {
}
/**
- * @see {@link GraphTraversal#key()}
+ * @see GraphTraversal#key()
*/
public static <A> GraphTraversal<A, String> key() {
return __.<A>start().key();
}
/**
- * @see {@link GraphTraversal#value()}
+ * @see GraphTraversal#value()
*/
public static <A, B> GraphTraversal<A, B> value() {
return __.<A>start().value();
}
/**
- * @see {@link GraphTraversal#path()}
+ * @see GraphTraversal#path()
*/
public static <A> GraphTraversal<A, Path> path() {
return __.<A>start().path();
}
/**
- * @see {@link GraphTraversal#match(Traversal[])}
+ * @see GraphTraversal#match(Traversal[])
*/
public static <A, B> GraphTraversal<A, Map<String, B>> match(final Traversal<?, ?>... matchTraversals) {
return __.<A>start().match(matchTraversals);
}
/**
- * @see {@link GraphTraversal#sack()}
+ * @see GraphTraversal#sack()
*/
public static <A, B> GraphTraversal<A, B> sack() {
return __.<A>start().sack();
}
/**
- * @see {@link GraphTraversal#loops()}
+ * @see GraphTraversal#loops()
*/
public static <A> GraphTraversal<A, Integer> loops() {
return __.<A>start().loops();
}
/**
- * @see {@link GraphTraversal#select(Pop, String)}
+ * @see GraphTraversal#select(Pop, String)
*/
public static <A, B> GraphTraversal<A, B> select(final Pop pop, final String selectKey) {
return __.<A>start().select(pop, selectKey);
}
/**
- * @see {@link GraphTraversal#select(String)}
+ * @see GraphTraversal#select(String)
*/
public static <A, B> GraphTraversal<A, B> select(final String selectKey) {
return __.<A>start().select(selectKey);
}
/**
- * @see {@link GraphTraversal#select(Pop, String, String, String...)}
+ * @see GraphTraversal#select(Pop, String, String, String...)
*/
public static <A, B> GraphTraversal<A, Map<String, B>> select(final Pop pop, final String selectKey1, final String selectKey2, final String... otherSelectKeys) {
return __.<A>start().select(pop, selectKey1, selectKey2, otherSelectKeys);
}
/**
- * @see {@link GraphTraversal#select(String, String, String...)}
+ * @see GraphTraversal#select(String, String, String...)
*/
public static <A, B> GraphTraversal<A, Map<String, B>> select(final String selectKey1, final String selectKey2, final String... otherSelectKeys) {
return __.<A>start().select(selectKey1, selectKey2, otherSelectKeys);
}
/**
- * @see {@link GraphTraversal#unfold()}
+ * @see GraphTraversal#unfold()
*/
public static <A> GraphTraversal<A, A> unfold() {
return __.<A>start().unfold();
}
/**
- * @see {@link GraphTraversal#fold()}
+ * @see GraphTraversal#fold()
*/
public static <A> GraphTraversal<A, List<A>> fold() {
return __.<A>start().fold();
}
/**
- * @see {@link GraphTraversal#fold(Object, BiFunction)}
+ * @see GraphTraversal#fold(Object, BiFunction)
*/
public static <A, B> GraphTraversal<A, B> fold(final B seed, final BiFunction<B, A, B> foldFunction) {
return __.<A>start().fold(seed, foldFunction);
}
/**
- * @see {@link GraphTraversal#count()}
+ * @see GraphTraversal#count()
*/
public static <A> GraphTraversal<A, Long> count() {
return __.<A>start().count();
}
/**
- * @see {@link GraphTraversal#count(Scope)}
+ * @see GraphTraversal#count(Scope)
*/
public static <A> GraphTraversal<A, Long> count(final Scope scope) {
return __.<A>start().count(scope);
}
/**
- * @see {@link GraphTraversal#sum()}
+ * @see GraphTraversal#sum()
*/
public static <A> GraphTraversal<A, Double> sum() {
return __.<A>start().sum();
}
/**
- * @see {@link GraphTraversal#sum(Scope)}
+ * @see GraphTraversal#sum(Scope)
*/
public static <A> GraphTraversal<A, Double> sum(final Scope scope) {
return __.<A>start().sum(scope);
}
/**
- * @see {@link GraphTraversal#min()}
+ * @see GraphTraversal#min()
*/
public static <A, B extends Number> GraphTraversal<A, B> min() {
return __.<A>start().min();
}
/**
- * @see {@link GraphTraversal#min(Scope)}
+ * @see GraphTraversal#min(Scope)
*/
public static <A, B extends Number> GraphTraversal<A, B> min(final Scope scope) {
return __.<A>start().min(scope);
}
/**
- * @see {@link GraphTraversal#max()}
+ * @see GraphTraversal#max()
*/
public static <A, B extends Number> GraphTraversal<A, B> max() {
return __.<A>start().max();
}
/**
- * @see {@link GraphTraversal#max(Scope)}
+ * @see GraphTraversal#max(Scope)
*/
public static <A, B extends Number> GraphTraversal<A, B> max(final Scope scope) {
return __.<A>start().max(scope);
}
/**
- * @see {@link GraphTraversal#mean()}
+ * @see GraphTraversal#mean()
*/
public static <A> GraphTraversal<A, Double> mean() {
return __.<A>start().mean();
}
/**
- * @see {@link GraphTraversal#mean(Scope)}
+ * @see GraphTraversal#mean(Scope)
*/
public static <A> GraphTraversal<A, Double> mean(final Scope scope) {
return __.<A>start().mean(scope);
}
/**
- * @see {@link GraphTraversal#group()}
+ * @see GraphTraversal#group()
*/
public static <A, K, V> GraphTraversal<A, Map<K, V>> group() {
return __.<A>start().group();
}
/**
- * @see {@link GraphTraversal#group()}
+ * @see GraphTraversal#group()
*/
@Deprecated
public static <A, K, V> GraphTraversal<A, Map<K, V>> groupV3d0() {
@@ -457,35 +468,35 @@ public class __ {
}
/**
- * @see {@link GraphTraversal#groupCount()}
+ * @see GraphTraversal#groupCount()
*/
public static <A, K> GraphTraversal<A, Map<K, Long>> groupCount() {
return __.<A>start().<K>groupCount();
}
/**
- * @see {@link GraphTraversal#tree()}
+ * @see GraphTraversal#tree()
*/
public static <A> GraphTraversal<A, Tree> tree() {
return __.<A>start().tree();
}
/**
- * @see {@link GraphTraversal#addV(String)}
+ * @see GraphTraversal#addV(String)
*/
public static <A> GraphTraversal<A, Vertex> addV(final String vertexLabel) {
return __.<A>start().addV(vertexLabel);
}
/**
- * @see {@link GraphTraversal#addV()}
+ * @see GraphTraversal#addV()
*/
public static <A> GraphTraversal<A, Vertex> addV() {
return __.<A>start().addV();
}
/**
- * @see {@link GraphTraversal#addV(Object...)}
+ * @see GraphTraversal#addV(Object...)
*/
@Deprecated
public static <A> GraphTraversal<A, Vertex> addV(final Object... propertyKeyValues) {
@@ -493,7 +504,7 @@ public class __ {
}
/**
- * @see {@link GraphTraversal#addE(Direction, String, String, Object...)}
+ * @see GraphTraversal#addE(Direction, String, String, Object...)
*/
@Deprecated
public static <A> GraphTraversal<A, Edge> addE(final Direction direction, final String firstVertexKeyOrEdgeLabel, final String edgeLabelOrSecondVertexKey, final Object... propertyKeyValues) {
@@ -501,7 +512,7 @@ public class __ {
}
/**
- * @see {@link GraphTraversal#addOutE(String, String, Object...)}
+ * @see GraphTraversal#addOutE(String, String, Object...)
*/
@Deprecated
public static <A> GraphTraversal<A, Edge> addOutE(final String firstVertexKeyOrEdgeLabel, final String edgeLabelOrSecondVertexKey, final Object... propertyKeyValues) {
@@ -509,7 +520,7 @@ public class __ {
}
/**
- * @see {@link GraphTraversal#addInE(String, String, Object...)}
+ * @see GraphTraversal#addInE(String, String, Object...)
*/
@Deprecated
public static <A> GraphTraversal<A, Edge> addInE(final String firstVertexKeyOrEdgeLabel, final String edgeLabelOrSecondVertexKey, final Object... propertyKeyValues) {
@@ -517,7 +528,7 @@ public class __ {
}
/**
- * @see {@link GraphTraversal#addE(String)}
+ * @see GraphTraversal#addE(String)
*/
public static <A> GraphTraversal<A, Edge> addE(final String edgeLabel) {
return __.<A>start().addE(edgeLabel);
@@ -525,188 +536,326 @@ public class __ {
///////////////////// FILTER STEPS /////////////////////
+ /**
+ * @see GraphTraversal#filter(Predicate)
+ */
public static <A> GraphTraversal<A, A> filter(final Predicate<Traverser<A>> predicate) {
return __.<A>start().filter(predicate);
}
+ /**
+ * @see GraphTraversal#filter(Traversal)
+ */
public static <A> GraphTraversal<A, A> filter(final Traversal<?, ?> filterTraversal) {
return __.<A>start().filter(filterTraversal);
}
+ /**
+ * @see GraphTraversal#and(Traversal[])
+ */
public static <A> GraphTraversal<A, A> and(final Traversal<?, ?>... andTraversals) {
return __.<A>start().and(andTraversals);
}
+ /**
+ * @see GraphTraversal#or(Traversal[])
+ */
public static <A> GraphTraversal<A, A> or(final Traversal<?, ?>... orTraversals) {
return __.<A>start().or(orTraversals);
}
+ /**
+ * @see GraphTraversal#inject(Object[])
+ */
public static <A> GraphTraversal<A, A> inject(final A... injections) {
return __.<A>start().inject((A[]) injections);
}
+ /**
+ * @see GraphTraversal#dedup(String...)
+ */
public static <A> GraphTraversal<A, A> dedup(final String... dedupLabels) {
return __.<A>start().dedup(dedupLabels);
}
+ /**
+ * @see GraphTraversal#dedup(Scope, String...)
+ */
public static <A> GraphTraversal<A, A> dedup(final Scope scope, final String... dedupLabels) {
return __.<A>start().dedup(scope, dedupLabels);
}
+ /**
+ * @see GraphTraversal#has(String, P)
+ */
public static <A> GraphTraversal<A, A> has(final String propertyKey, final P<?> predicate) {
return __.<A>start().has(propertyKey, predicate);
}
+ /**
+ * @see GraphTraversal#has(T, P)
+ */
public static <A> GraphTraversal<A, A> has(final T accessor, final P<?> predicate) {
return __.<A>start().has(accessor, predicate);
}
+ /**
+ * @see GraphTraversal#has(String, Object)
+ */
public static <A> GraphTraversal<A, A> has(final String propertyKey, final Object value) {
return __.<A>start().has(propertyKey, value);
}
+ /**
+ * @see GraphTraversal#has(T, Object)
+ */
public static <A> GraphTraversal<A, A> has(final T accessor, final Object value) {
return __.<A>start().has(accessor, value);
}
+ /**
+ * @see GraphTraversal#has(String, String, Object)
+ */
public static <A> GraphTraversal<A, A> has(final String label, final String propertyKey, final Object value) {
return __.<A>start().has(label, propertyKey, value);
}
+ /**
+ * @see GraphTraversal#has(String, String, P)
+ */
public static <A> GraphTraversal<A, A> has(final String label, final String propertyKey, final P<?> predicate) {
return __.<A>start().has(label, propertyKey, predicate);
}
+ /**
+ * @see GraphTraversal#has(String, Traversal)
+ */
public static <A> GraphTraversal<A, A> has(final String propertyKey, final Traversal<?, ?> propertyTraversal) {
return __.<A>start().has(propertyKey, propertyTraversal);
}
+ /**
+ * @see GraphTraversal#has(String)
+ */
public static <A> GraphTraversal<A, A> has(final String propertyKey) {
return __.<A>start().has(propertyKey);
}
+ /**
+ * @see GraphTraversal#hasNot(String)
+ */
public static <A> GraphTraversal<A, A> hasNot(final String propertyKey) {
return __.<A>start().hasNot(propertyKey);
}
+ /**
+ * @see GraphTraversal#hasLabel(String...)
+ */
public static <A> GraphTraversal<A, A> hasLabel(final String... labels) {
return __.<A>start().hasLabel(labels);
}
+ /**
+ * @see GraphTraversal#hasId(Object...)
+ */
public static <A> GraphTraversal<A, A> hasId(final Object... ids) {
return __.<A>start().hasId(ids);
}
+ /**
+ * @see GraphTraversal#hasKey(String...)
+ */
public static <A> GraphTraversal<A, A> hasKey(final String... keys) {
return __.<A>start().hasKey(keys);
}
+ /**
+ * @see GraphTraversal#hasValue(Object...)
+ */
public static <A> GraphTraversal<A, A> hasValue(final Object... values) {
return __.<A>start().hasValue(values);
}
+ /**
+ * @see GraphTraversal#where(String, P)
+ */
public static <A> GraphTraversal<A, A> where(final String startKey, final P<String> predicate) {
return __.<A>start().where(startKey, predicate);
}
+ /**
+ * @see GraphTraversal#where(P)
+ */
public static <A> GraphTraversal<A, A> where(final P<String> predicate) {
return __.<A>start().where(predicate);
}
+ /**
+ * @see GraphTraversal#where(Traversal)
+ */
public static <A> GraphTraversal<A, A> where(final Traversal<?, ?> whereTraversal) {
return __.<A>start().where(whereTraversal);
}
+ /**
+ * @see GraphTraversal#is(P)
+ */
public static <A> GraphTraversal<A, A> is(final P<A> predicate) {
return __.<A>start().is(predicate);
}
+ /**
+ * @see GraphTraversal#is(Object)
+ */
public static <A> GraphTraversal<A, A> is(final Object value) {
return __.<A>start().is(value);
}
+ /**
+ * @see GraphTraversal#not(Traversal)
+ */
public static <A> GraphTraversal<A, A> not(final Traversal<?, ?> notTraversal) {
return __.<A>start().not(notTraversal);
}
+ /**
+ * @see GraphTraversal#coin(double)
+ */
public static <A> GraphTraversal<A, A> coin(final double probability) {
return __.<A>start().coin(probability);
}
+ /**
+ * @see GraphTraversal#range(long, long)
+ */
public static <A> GraphTraversal<A, A> range(final long low, final long high) {
return __.<A>start().range(low, high);
}
+ /**
+ * @see GraphTraversal#range(Scope, long, long)
+ */
public static <A> GraphTraversal<A, A> range(final Scope scope, final long low, final long high) {
return __.<A>start().range(scope, low, high);
}
+ /**
+ * @see GraphTraversal#limit(long)
+ */
public static <A> GraphTraversal<A, A> limit(final long limit) {
return __.<A>start().limit(limit);
}
+ /**
+ * @see GraphTraversal#limit(Scope, long)
+ */
public static <A> GraphTraversal<A, A> limit(final Scope scope, final long limit) {
return __.<A>start().limit(scope, limit);
}
+ /**
+ * @see GraphTraversal#tail()
+ */
public static <A> GraphTraversal<A, A> tail() {
return __.<A>start().tail();
}
+ /**
+ * @see GraphTraversal#tail(long)
+ */
public static <A> GraphTraversal<A, A> tail(final long limit) {
return __.<A>start().tail(limit);
}
+ /**
+ * @see GraphTraversal#tail(Scope)
+ */
public static <A> GraphTraversal<A, A> tail(final Scope scope) {
return __.<A>start().tail(scope);
}
+ /**
+ * @see GraphTraversal#tail(Scope, long)
+ */
public static <A> GraphTraversal<A, A> tail(final Scope scope, final long limit) {
return __.<A>start().tail(scope, limit);
}
+ /**
+ * @see GraphTraversal#simplePath()
+ */
public static <A> GraphTraversal<A, A> simplePath() {
return __.<A>start().simplePath();
}
+ /**
+ * @see GraphTraversal#cyclicPath()
+ */
public static <A> GraphTraversal<A, A> cyclicPath() {
return __.<A>start().cyclicPath();
}
+ /**
+ * @see GraphTraversal#sample(int)
+ */
public static <A> GraphTraversal<A, A> sample(final int amountToSample) {
return __.<A>start().sample(amountToSample);
}
+ /**
+ * @see GraphTraversal#sample(Scope, int)
+ */
public static <A> GraphTraversal<A, A> sample(final Scope scope, final int amountToSample) {
return __.<A>start().sample(scope, amountToSample);
}
+ /**
+ * @see GraphTraversal#drop()
+ */
public static <A> GraphTraversal<A, A> drop() {
return __.<A>start().drop();
}
///////////////////// SIDE-EFFECT STEPS /////////////////////
+ /**
+ * @see GraphTraversal#sideEffect(Consumer)
+ */
public static <A> GraphTraversal<A, A> sideEffect(final Consumer<Traverser<A>> consumer) {
return __.<A>start().sideEffect(consumer);
}
+ /**
+ * @see GraphTraversal#sideEffect(Traversal)
+ */
public static <A> GraphTraversal<A, A> sideEffect(final Traversal<?, ?> sideEffectTraversal) {
return __.<A>start().sideEffect(sideEffectTraversal);
}
+ /**
+ * @see GraphTraversal#cap(String, String...)
+ */
public static <A, B> GraphTraversal<A, B> cap(final String sideEffectKey, String... sideEffectKeys) {
return __.<A>start().cap(sideEffectKey, sideEffectKeys);
}
+ /**
+ * @see GraphTraversal#subgraph(String)
+ */
public static <A> GraphTraversal<A, Edge> subgraph(final String sideEffectKey) {
return __.<A>start().subgraph(sideEffectKey);
}
+ /**
+ * @see GraphTraversal#aggregate(String)
+ */
public static <A> GraphTraversal<A, A> aggregate(final String sideEffectKey) {
return __.<A>start().aggregate(sideEffectKey);
}
+ /**
+ * @see GraphTraversal#group(String)
+ */
public static <A> GraphTraversal<A, A> group(final String sideEffectKey) {
return __.<A>start().group(sideEffectKey);
}
@@ -719,18 +868,30 @@ public class __ {
return __.<A>start().groupV3d0(sideEffectKey);
}
+ /**
+ * @see GraphTraversal#groupCount(String)
+ */
public static <A> GraphTraversal<A, A> groupCount(final String sideEffectKey) {
return __.<A>start().groupCount(sideEffectKey);
}
+ /**
+ * @see GraphTraversal#timeLimit(long)
+ */
public static <A> GraphTraversal<A, A> timeLimit(final long timeLimit) {
return __.<A>start().timeLimit(timeLimit);
}
+ /**
+ * @see GraphTraversal#tree(String)
+ */
public static <A> GraphTraversal<A, A> tree(final String sideEffectKey) {
return __.<A>start().tree(sideEffectKey);
}
+ /**
+ * @see GraphTraversal#sack(BiFunction)
+ */
public static <A, V, U> GraphTraversal<A, A> sack(final BiFunction<V, U, V> sackOperator) {
return __.<A>start().sack(sackOperator);
}
@@ -743,98 +904,167 @@ public class __ {
return __.<A>start().sack(sackOperator, elementPropertyKey);
}
+ /**
+ * @see GraphTraversal#store(String)
+ */
public static <A> GraphTraversal<A, A> store(final String sideEffectKey) {
return __.<A>start().store(sideEffectKey);
}
+ /**
+ * @see GraphTraversal#property(Object, Object, Object...)
+ */
public static <A> GraphTraversal<A, A> property(final Object key, final Object value, final Object... keyValues) {
return __.<A>start().property(key, value, keyValues);
}
+ /**
+ * @see GraphTraversal#property(VertexProperty.Cardinality, Object, Object, Object...)
+ */
public static <A> GraphTraversal<A, A> property(final VertexProperty.Cardinality cardinality, final Object key, final Object value, final Object... keyValues) {
return __.<A>start().property(cardinality, key, value, keyValues);
}
///////////////////// BRANCH STEPS /////////////////////
+ /**
+ * @see GraphTraversal#branch(Function)
+ */
public static <A, M, B> GraphTraversal<A, B> branch(final Function<Traverser<A>, M> function) {
return __.<A>start().branch(function);
}
+ /**
+ * @see GraphTraversal#branch(Traversal)
+ */
public static <A, M, B> GraphTraversal<A, B> branch(final Traversal<?, M> traversalFunction) {
return __.<A>start().branch(traversalFunction);
}
+ /**
+ * @see GraphTraversal#choose(Predicate, Traversal, Traversal)
+ */
public static <A, B> GraphTraversal<A, B> choose(final Predicate<A> choosePredicate, final Traversal<?, B> trueChoice, final Traversal<?, B> falseChoice) {
return __.<A>start().choose(choosePredicate, trueChoice, falseChoice);
}
+ /**
+ * @see GraphTraversal#choose(Function)
+ */
public static <A, M, B> GraphTraversal<A, B> choose(final Function<A, M> choiceFunction) {
return __.<A>start().choose(choiceFunction);
}
+ /**
+ * @see GraphTraversal#choose(Traversal)
+ */
public static <A, M, B> GraphTraversal<A, B> choose(final Traversal<?, M> traversalFunction) {
return __.<A>start().choose(traversalFunction);
}
+ /**
+ * @see GraphTraversal#choose(Traversal, Traversal, Traversal)
+ */
public static <A, M, B> GraphTraversal<A, B> choose(final Traversal<?, M> traversalPredicate, final Traversal<?, B> trueChoice, final Traversal<?, B> falseChoice) {
return __.<A>start().choose(traversalPredicate, trueChoice, falseChoice);
}
+ /**
+ * @see GraphTraversal#union(Traversal[])
+ */
public static <A, B> GraphTraversal<A, B> union(final Traversal<?, B>... traversals) {
return __.<A>start().union(traversals);
}
+ /**
+ * @see GraphTraversal#coalesce(Traversal[])
+ */
public static <A, B> GraphTraversal<A, B> coalesce(final Traversal<?, B>... traversals) {
return __.<A>start().coalesce(traversals);
}
+ /**
+ * @see GraphTraversal#repeat(Traversal)
+ */
public static <A> GraphTraversal<A, A> repeat(final Traversal<?, A> traversal) {
return __.<A>start().repeat(traversal);
}
+ /**
+ * @see GraphTraversal#emit(Traversal)
+ */
public static <A> GraphTraversal<A, A> emit(final Traversal<?, ?> emitTraversal) {
return __.<A>start().emit(emitTraversal);
}
+ /**
+ * @see GraphTraversal#emit(Predicate)
+ */
public static <A> GraphTraversal<A, A> emit(final Predicate<Traverser<A>> emitPredicate) {
return __.<A>start().emit(emitPredicate);
}
+ /**
+ * @see GraphTraversal#until(Traversal)
+ */
public static <A> GraphTraversal<A, A> until(final Traversal<?, ?> untilTraversal) {
return __.<A>start().until(untilTraversal);
}
+ /**
+ * @see GraphTraversal#until(Predicate)
+ */
public static <A> GraphTraversal<A, A> until(final Predicate<Traverser<A>> untilPredicate) {
return __.<A>start().until(untilPredicate);
}
+ /**
+ * @see GraphTraversal#times(int)
+ */
public static <A> GraphTraversal<A, A> times(final int maxLoops) {
return __.<A>start().times(maxLoops);
}
+ /**
+ * @see GraphTraversal#emit()
+ */
public static <A> GraphTraversal<A, A> emit() {
return __.<A>start().emit();
}
+ /**
+ * @see GraphTraversal#local(Traversal)
+ */
public static <A, B> GraphTraversal<A, B> local(final Traversal<?, B> localTraversal) {
return __.<A>start().local(localTraversal);
}
///////////////////// UTILITY STEPS /////////////////////
+ /**
+ * @see GraphTraversal#as(String, String...)
+ */
public static <A> GraphTraversal<A, A> as(final String label, final String... labels) {
return __.<A>start().as(label, labels);
}
+ /**
+ * @see GraphTraversal#barrier()
+ */
public static <A> GraphTraversal<A, A> barrier() {
return __.<A>start().barrier();
}
+ /**
+ * @see GraphTraversal#barrier(int)
+ */
public static <A> GraphTraversal<A, A> barrier(final int maxBarrierSize) {
return __.<A>start().barrier(maxBarrierSize);
}
+ /**
+ * @see GraphTraversal#barrier(Consumer)
+ */
public static <A> GraphTraversal<A, A> barrier(final Consumer<TraverserSet<Object>> barrierConsumer) {
return __.<A>start().barrier(barrierConsumer);
}