You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by fl...@apache.org on 2018/01/21 12:57:18 UTC
[3/5] tinkerpop git commit: TINKERPOP-1868 Remove unnecessary spaces
http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/535b309e/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversal.cs
----------------------------------------------------------------------
diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversal.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversal.cs
index ed4b867..d8e26ad 100644
--- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversal.cs
+++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversal.cs
@@ -65,1614 +65,1614 @@ namespace Gremlin.Net.Process.Traversal
/// <summary>
/// Adds the V step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Vertex > V (params object[] vertexIdsOrElements)
+ public GraphTraversal<S, Vertex> V (params object[] vertexIdsOrElements)
{
- var args = new List< object >(0 + vertexIdsOrElements.Length) {};
+ var args = new List<object>(0 + vertexIdsOrElements.Length) {};
args.AddRange(vertexIdsOrElements);
Bytecode.AddStep("V", args.ToArray());
- return Wrap< S , Vertex >(this);
+ return Wrap<S, Vertex>(this);
}
/// <summary>
/// Adds the addE step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Edge > AddE (Direction direction, string firstVertexKeyOrEdgeLabel, string edgeLabelOrSecondVertexKey, params object[] propertyKeyValues)
+ public GraphTraversal<S, Edge> AddE (Direction direction, string firstVertexKeyOrEdgeLabel, string edgeLabelOrSecondVertexKey, params object[] propertyKeyValues)
{
- var args = new List< object >(3 + propertyKeyValues.Length) {direction, firstVertexKeyOrEdgeLabel, edgeLabelOrSecondVertexKey};
+ var args = new List<object>(3 + propertyKeyValues.Length) {direction, firstVertexKeyOrEdgeLabel, edgeLabelOrSecondVertexKey};
args.AddRange(propertyKeyValues);
Bytecode.AddStep("addE", args.ToArray());
- return Wrap< S , Edge >(this);
+ return Wrap<S, Edge>(this);
}
/// <summary>
/// Adds the addE step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Edge > AddE (string edgeLabel)
+ public GraphTraversal<S, Edge> AddE (string edgeLabel)
{
Bytecode.AddStep("addE", edgeLabel);
- return Wrap< S , Edge >(this);
+ return Wrap<S, Edge>(this);
}
/// <summary>
/// Adds the addInE step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Edge > AddInE (string firstVertexKeyOrEdgeLabel, string edgeLabelOrSecondVertexKey, params object[] propertyKeyValues)
+ public GraphTraversal<S, Edge> AddInE (string firstVertexKeyOrEdgeLabel, string edgeLabelOrSecondVertexKey, params object[] propertyKeyValues)
{
- var args = new List< object >(2 + propertyKeyValues.Length) {firstVertexKeyOrEdgeLabel, edgeLabelOrSecondVertexKey};
+ var args = new List<object>(2 + propertyKeyValues.Length) {firstVertexKeyOrEdgeLabel, edgeLabelOrSecondVertexKey};
args.AddRange(propertyKeyValues);
Bytecode.AddStep("addInE", args.ToArray());
- return Wrap< S , Edge >(this);
+ return Wrap<S, Edge>(this);
}
/// <summary>
/// Adds the addOutE step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Edge > AddOutE (string firstVertexKeyOrEdgeLabel, string edgeLabelOrSecondVertexKey, params object[] propertyKeyValues)
+ public GraphTraversal<S, Edge> AddOutE (string firstVertexKeyOrEdgeLabel, string edgeLabelOrSecondVertexKey, params object[] propertyKeyValues)
{
- var args = new List< object >(2 + propertyKeyValues.Length) {firstVertexKeyOrEdgeLabel, edgeLabelOrSecondVertexKey};
+ var args = new List<object>(2 + propertyKeyValues.Length) {firstVertexKeyOrEdgeLabel, edgeLabelOrSecondVertexKey};
args.AddRange(propertyKeyValues);
Bytecode.AddStep("addOutE", args.ToArray());
- return Wrap< S , Edge >(this);
+ return Wrap<S, Edge>(this);
}
/// <summary>
/// Adds the addV step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Vertex > AddV ()
+ public GraphTraversal<S, Vertex> AddV ()
{
Bytecode.AddStep("addV");
- return Wrap< S , Vertex >(this);
+ return Wrap<S, Vertex>(this);
}
/// <summary>
/// Adds the addV step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Vertex > AddV (params object[] propertyKeyValues)
+ public GraphTraversal<S, Vertex> AddV (params object[] propertyKeyValues)
{
- var args = new List< object >(0 + propertyKeyValues.Length) {};
+ var args = new List<object>(0 + propertyKeyValues.Length) {};
args.AddRange(propertyKeyValues);
Bytecode.AddStep("addV", args.ToArray());
- return Wrap< S , Vertex >(this);
+ return Wrap<S, Vertex>(this);
}
/// <summary>
/// Adds the addV step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Vertex > AddV (string vertexLabel)
+ public GraphTraversal<S, Vertex> AddV (string vertexLabel)
{
Bytecode.AddStep("addV", vertexLabel);
- return Wrap< S , Vertex >(this);
+ return Wrap<S, Vertex>(this);
}
/// <summary>
/// Adds the aggregate step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Aggregate (string sideEffectKey)
+ public GraphTraversal<S, E> Aggregate (string sideEffectKey)
{
Bytecode.AddStep("aggregate", sideEffectKey);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the and step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > And (params ITraversal[] andTraversals)
+ public GraphTraversal<S, E> And (params ITraversal[] andTraversals)
{
- var args = new List< object >(0 + andTraversals.Length) {};
+ var args = new List<object>(0 + andTraversals.Length) {};
args.AddRange(andTraversals);
Bytecode.AddStep("and", args.ToArray());
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the as step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > As (string stepLabel, params string[] stepLabels)
+ public GraphTraversal<S, E> As (string stepLabel, params string[] stepLabels)
{
- var args = new List< object >(1 + stepLabels.Length) {stepLabel};
+ var args = new List<object>(1 + stepLabels.Length) {stepLabel};
args.AddRange(stepLabels);
Bytecode.AddStep("as", args.ToArray());
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the barrier step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Barrier ()
+ public GraphTraversal<S, E> Barrier ()
{
Bytecode.AddStep("barrier");
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the barrier step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Barrier (object barrierConsumer)
+ public GraphTraversal<S, E> Barrier (object barrierConsumer)
{
Bytecode.AddStep("barrier", barrierConsumer);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the barrier step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Barrier (int maxBarrierSize)
+ public GraphTraversal<S, E> Barrier (int maxBarrierSize)
{
Bytecode.AddStep("barrier", maxBarrierSize);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the both step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Vertex > Both (params string[] edgeLabels)
+ public GraphTraversal<S, Vertex> Both (params string[] edgeLabels)
{
- var args = new List< object >(0 + edgeLabels.Length) {};
+ var args = new List<object>(0 + edgeLabels.Length) {};
args.AddRange(edgeLabels);
Bytecode.AddStep("both", args.ToArray());
- return Wrap< S , Vertex >(this);
+ return Wrap<S, Vertex>(this);
}
/// <summary>
/// Adds the bothE step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Edge > BothE (params string[] edgeLabels)
+ public GraphTraversal<S, Edge> BothE (params string[] edgeLabels)
{
- var args = new List< object >(0 + edgeLabels.Length) {};
+ var args = new List<object>(0 + edgeLabels.Length) {};
args.AddRange(edgeLabels);
Bytecode.AddStep("bothE", args.ToArray());
- return Wrap< S , Edge >(this);
+ return Wrap<S, Edge>(this);
}
/// <summary>
/// Adds the bothV step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Vertex > BothV ()
+ public GraphTraversal<S, Vertex> BothV ()
{
Bytecode.AddStep("bothV");
- return Wrap< S , Vertex >(this);
+ return Wrap<S, Vertex>(this);
}
/// <summary>
/// Adds the branch step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Branch<E2> (object function)
+ public GraphTraversal<S, E2> Branch<E2> (object function)
{
Bytecode.AddStep("branch", function);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the branch step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Branch<E2> (ITraversal branchTraversal)
+ public GraphTraversal<S, E2> Branch<E2> (ITraversal branchTraversal)
{
Bytecode.AddStep("branch", branchTraversal);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the by step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > By ()
+ public GraphTraversal<S, E> By ()
{
Bytecode.AddStep("by");
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the by step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > By (object comparator)
+ public GraphTraversal<S, E> By (object comparator)
{
Bytecode.AddStep("by", comparator);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the by step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > By (object function, object comparator)
+ public GraphTraversal<S, E> By (object function, object comparator)
{
Bytecode.AddStep("by", function, comparator);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the by step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > By (Order order)
+ public GraphTraversal<S, E> By (Order order)
{
Bytecode.AddStep("by", order);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the by step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > By (string key)
+ public GraphTraversal<S, E> By (string key)
{
Bytecode.AddStep("by", key);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the by step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > By (string key, object comparator)
+ public GraphTraversal<S, E> By (string key, object comparator)
{
Bytecode.AddStep("by", key, comparator);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the by step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > By (T token)
+ public GraphTraversal<S, E> By (T token)
{
Bytecode.AddStep("by", token);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the by step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > By (ITraversal traversal)
+ public GraphTraversal<S, E> By (ITraversal traversal)
{
Bytecode.AddStep("by", traversal);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the by step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > By (ITraversal traversal, object comparator)
+ public GraphTraversal<S, E> By (ITraversal traversal, object comparator)
{
Bytecode.AddStep("by", traversal, comparator);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the cap step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Cap<E2> (string sideEffectKey, params string[] sideEffectKeys)
+ public GraphTraversal<S, E2> Cap<E2> (string sideEffectKey, params string[] sideEffectKeys)
{
- var args = new List< object >(1 + sideEffectKeys.Length) {sideEffectKey};
+ var args = new List<object>(1 + sideEffectKeys.Length) {sideEffectKey};
args.AddRange(sideEffectKeys);
Bytecode.AddStep("cap", args.ToArray());
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the choose step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Choose<E2> (object choiceFunction)
+ public GraphTraversal<S, E2> Choose<E2> (object choiceFunction)
{
Bytecode.AddStep("choose", choiceFunction);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the choose step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Choose<E2> (TraversalPredicate choosePredicate, ITraversal trueChoice)
+ public GraphTraversal<S, E2> Choose<E2> (TraversalPredicate choosePredicate, ITraversal trueChoice)
{
Bytecode.AddStep("choose", choosePredicate, trueChoice);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the choose step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Choose<E2> (TraversalPredicate choosePredicate, ITraversal trueChoice, ITraversal falseChoice)
+ public GraphTraversal<S, E2> Choose<E2> (TraversalPredicate choosePredicate, ITraversal trueChoice, ITraversal falseChoice)
{
Bytecode.AddStep("choose", choosePredicate, trueChoice, falseChoice);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the choose step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Choose<E2> (ITraversal choiceTraversal)
+ public GraphTraversal<S, E2> Choose<E2> (ITraversal choiceTraversal)
{
Bytecode.AddStep("choose", choiceTraversal);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the choose step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Choose<E2> (ITraversal traversalPredicate, ITraversal trueChoice)
+ public GraphTraversal<S, E2> Choose<E2> (ITraversal traversalPredicate, ITraversal trueChoice)
{
Bytecode.AddStep("choose", traversalPredicate, trueChoice);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the choose step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Choose<E2> (ITraversal traversalPredicate, ITraversal trueChoice, ITraversal falseChoice)
+ public GraphTraversal<S, E2> Choose<E2> (ITraversal traversalPredicate, ITraversal trueChoice, ITraversal falseChoice)
{
Bytecode.AddStep("choose", traversalPredicate, trueChoice, falseChoice);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the coalesce step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Coalesce<E2> (params ITraversal[] coalesceTraversals)
+ public GraphTraversal<S, E2> Coalesce<E2> (params ITraversal[] coalesceTraversals)
{
- var args = new List< object >(0 + coalesceTraversals.Length) {};
+ var args = new List<object>(0 + coalesceTraversals.Length) {};
args.AddRange(coalesceTraversals);
Bytecode.AddStep("coalesce", args.ToArray());
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the coin step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Coin (double probability)
+ public GraphTraversal<S, E> Coin (double probability)
{
Bytecode.AddStep("coin", probability);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the constant step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Constant<E2> (E2 e)
+ public GraphTraversal<S, E2> Constant<E2> (E2 e)
{
Bytecode.AddStep("constant", e);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the count step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , long > Count ()
+ public GraphTraversal<S, long> Count ()
{
Bytecode.AddStep("count");
- return Wrap< S , long >(this);
+ return Wrap<S, long>(this);
}
/// <summary>
/// Adds the count step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , long > Count (Scope scope)
+ public GraphTraversal<S, long> Count (Scope scope)
{
Bytecode.AddStep("count", scope);
- return Wrap< S , long >(this);
+ return Wrap<S, long>(this);
}
/// <summary>
/// Adds the cyclicPath step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > CyclicPath ()
+ public GraphTraversal<S, E> CyclicPath ()
{
Bytecode.AddStep("cyclicPath");
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the dedup step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Dedup (Scope scope, params string[] dedupLabels)
+ public GraphTraversal<S, E> Dedup (Scope scope, params string[] dedupLabels)
{
- var args = new List< object >(1 + dedupLabels.Length) {scope};
+ var args = new List<object>(1 + dedupLabels.Length) {scope};
args.AddRange(dedupLabels);
Bytecode.AddStep("dedup", args.ToArray());
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the dedup step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Dedup (params string[] dedupLabels)
+ public GraphTraversal<S, E> Dedup (params string[] dedupLabels)
{
- var args = new List< object >(0 + dedupLabels.Length) {};
+ var args = new List<object>(0 + dedupLabels.Length) {};
args.AddRange(dedupLabels);
Bytecode.AddStep("dedup", args.ToArray());
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the drop step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Drop ()
+ public GraphTraversal<S, E> Drop ()
{
Bytecode.AddStep("drop");
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the emit step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Emit ()
+ public GraphTraversal<S, E> Emit ()
{
Bytecode.AddStep("emit");
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the emit step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Emit (TraversalPredicate emitPredicate)
+ public GraphTraversal<S, E> Emit (TraversalPredicate emitPredicate)
{
Bytecode.AddStep("emit", emitPredicate);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the emit step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Emit (ITraversal emitTraversal)
+ public GraphTraversal<S, E> Emit (ITraversal emitTraversal)
{
Bytecode.AddStep("emit", emitTraversal);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the filter step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Filter (TraversalPredicate predicate)
+ public GraphTraversal<S, E> Filter (TraversalPredicate predicate)
{
Bytecode.AddStep("filter", predicate);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the filter step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Filter (ITraversal filterTraversal)
+ public GraphTraversal<S, E> Filter (ITraversal filterTraversal)
{
Bytecode.AddStep("filter", filterTraversal);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the flatMap step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > FlatMap<E2> (object function)
+ public GraphTraversal<S, E2> FlatMap<E2> (object function)
{
Bytecode.AddStep("flatMap", function);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the flatMap step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > FlatMap<E2> (ITraversal flatMapTraversal)
+ public GraphTraversal<S, E2> FlatMap<E2> (ITraversal flatMapTraversal)
{
Bytecode.AddStep("flatMap", flatMapTraversal);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the fold step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , IList<E> > Fold ()
+ public GraphTraversal<S, IList<E>> Fold ()
{
Bytecode.AddStep("fold");
- return Wrap< S , IList<E> >(this);
+ return Wrap<S, IList<E>>(this);
}
/// <summary>
/// Adds the fold step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Fold<E2> (E2 seed, object foldFunction)
+ public GraphTraversal<S, E2> Fold<E2> (E2 seed, object foldFunction)
{
Bytecode.AddStep("fold", seed, foldFunction);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the from step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > From (string fromStepLabel)
+ public GraphTraversal<S, E> From (string fromStepLabel)
{
Bytecode.AddStep("from", fromStepLabel);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the from step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > From (ITraversal fromVertex)
+ public GraphTraversal<S, E> From (ITraversal fromVertex)
{
Bytecode.AddStep("from", fromVertex);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the group step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , IDictionary<K, V> > Group<K, V> ()
+ public GraphTraversal<S, IDictionary<K, V>> Group<K, V> ()
{
Bytecode.AddStep("group");
- return Wrap< S , IDictionary<K, V> >(this);
+ return Wrap<S, IDictionary<K, V>>(this);
}
/// <summary>
/// Adds the group step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Group (string sideEffectKey)
+ public GraphTraversal<S, E> Group (string sideEffectKey)
{
Bytecode.AddStep("group", sideEffectKey);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the groupCount step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , IDictionary<K, long> > GroupCount<K> ()
+ public GraphTraversal<S, IDictionary<K, long>> GroupCount<K> ()
{
Bytecode.AddStep("groupCount");
- return Wrap< S , IDictionary<K, long> >(this);
+ return Wrap<S, IDictionary<K, long>>(this);
}
/// <summary>
/// Adds the groupCount step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > GroupCount (string sideEffectKey)
+ public GraphTraversal<S, E> GroupCount (string sideEffectKey)
{
Bytecode.AddStep("groupCount", sideEffectKey);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the groupV3d0 step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , IDictionary<K, V> > GroupV3d0<K, V> ()
+ public GraphTraversal<S, IDictionary<K, V>> GroupV3d0<K, V> ()
{
Bytecode.AddStep("groupV3d0");
- return Wrap< S , IDictionary<K, V> >(this);
+ return Wrap<S, IDictionary<K, V>>(this);
}
/// <summary>
/// Adds the groupV3d0 step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > GroupV3d0 (string sideEffectKey)
+ public GraphTraversal<S, E> GroupV3d0 (string sideEffectKey)
{
Bytecode.AddStep("groupV3d0", sideEffectKey);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the has step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Has (string propertyKey)
+ public GraphTraversal<S, E> Has (string propertyKey)
{
Bytecode.AddStep("has", propertyKey);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the has step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Has (string propertyKey, object value)
+ public GraphTraversal<S, E> Has (string propertyKey, object value)
{
Bytecode.AddStep("has", propertyKey, value);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the has step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Has (string propertyKey, TraversalPredicate predicate)
+ public GraphTraversal<S, E> Has (string propertyKey, TraversalPredicate predicate)
{
Bytecode.AddStep("has", propertyKey, predicate);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the has step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Has (string label, string propertyKey, object value)
+ public GraphTraversal<S, E> Has (string label, string propertyKey, object value)
{
Bytecode.AddStep("has", label, propertyKey, value);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the has step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Has (string label, string propertyKey, TraversalPredicate predicate)
+ public GraphTraversal<S, E> Has (string label, string propertyKey, TraversalPredicate predicate)
{
Bytecode.AddStep("has", label, propertyKey, predicate);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the has step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Has (string propertyKey, ITraversal propertyTraversal)
+ public GraphTraversal<S, E> Has (string propertyKey, ITraversal propertyTraversal)
{
Bytecode.AddStep("has", propertyKey, propertyTraversal);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the has step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Has (T accessor, object value)
+ public GraphTraversal<S, E> Has (T accessor, object value)
{
Bytecode.AddStep("has", accessor, value);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the has step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Has (T accessor, TraversalPredicate predicate)
+ public GraphTraversal<S, E> Has (T accessor, TraversalPredicate predicate)
{
Bytecode.AddStep("has", accessor, predicate);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the has step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Has (T accessor, ITraversal propertyTraversal)
+ public GraphTraversal<S, E> Has (T accessor, ITraversal propertyTraversal)
{
Bytecode.AddStep("has", accessor, propertyTraversal);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the hasId step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > HasId (object id, params object[] otherIds)
+ public GraphTraversal<S, E> HasId (object id, params object[] otherIds)
{
- var args = new List< object >(1 + otherIds.Length) {id};
+ var args = new List<object>(1 + otherIds.Length) {id};
args.AddRange(otherIds);
Bytecode.AddStep("hasId", args.ToArray());
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the hasId step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > HasId (TraversalPredicate predicate)
+ public GraphTraversal<S, E> HasId (TraversalPredicate predicate)
{
Bytecode.AddStep("hasId", predicate);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the hasKey step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > HasKey (TraversalPredicate predicate)
+ public GraphTraversal<S, E> HasKey (TraversalPredicate predicate)
{
Bytecode.AddStep("hasKey", predicate);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the hasKey step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > HasKey (string label, params string[] otherLabels)
+ public GraphTraversal<S, E> HasKey (string label, params string[] otherLabels)
{
- var args = new List< object >(1 + otherLabels.Length) {label};
+ var args = new List<object>(1 + otherLabels.Length) {label};
args.AddRange(otherLabels);
Bytecode.AddStep("hasKey", args.ToArray());
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the hasLabel step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > HasLabel (TraversalPredicate predicate)
+ public GraphTraversal<S, E> HasLabel (TraversalPredicate predicate)
{
Bytecode.AddStep("hasLabel", predicate);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the hasLabel step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > HasLabel (string label, params string[] otherLabels)
+ public GraphTraversal<S, E> HasLabel (string label, params string[] otherLabels)
{
- var args = new List< object >(1 + otherLabels.Length) {label};
+ var args = new List<object>(1 + otherLabels.Length) {label};
args.AddRange(otherLabels);
Bytecode.AddStep("hasLabel", args.ToArray());
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the hasNot step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > HasNot (string propertyKey)
+ public GraphTraversal<S, E> HasNot (string propertyKey)
{
Bytecode.AddStep("hasNot", propertyKey);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the hasValue step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > HasValue (object value, params object[] otherValues)
+ public GraphTraversal<S, E> HasValue (object value, params object[] otherValues)
{
- var args = new List< object >(1 + otherValues.Length) {value};
+ var args = new List<object>(1 + otherValues.Length) {value};
args.AddRange(otherValues);
Bytecode.AddStep("hasValue", args.ToArray());
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the hasValue step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > HasValue (TraversalPredicate predicate)
+ public GraphTraversal<S, E> HasValue (TraversalPredicate predicate)
{
Bytecode.AddStep("hasValue", predicate);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the id step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , object > Id ()
+ public GraphTraversal<S, object> Id ()
{
Bytecode.AddStep("id");
- return Wrap< S , object >(this);
+ return Wrap<S, object>(this);
}
/// <summary>
/// Adds the identity step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Identity ()
+ public GraphTraversal<S, E> Identity ()
{
Bytecode.AddStep("identity");
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the in step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Vertex > In (params string[] edgeLabels)
+ public GraphTraversal<S, Vertex> In (params string[] edgeLabels)
{
- var args = new List< object >(0 + edgeLabels.Length) {};
+ var args = new List<object>(0 + edgeLabels.Length) {};
args.AddRange(edgeLabels);
Bytecode.AddStep("in", args.ToArray());
- return Wrap< S , Vertex >(this);
+ return Wrap<S, Vertex>(this);
}
/// <summary>
/// Adds the inE step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Edge > InE (params string[] edgeLabels)
+ public GraphTraversal<S, Edge> InE (params string[] edgeLabels)
{
- var args = new List< object >(0 + edgeLabels.Length) {};
+ var args = new List<object>(0 + edgeLabels.Length) {};
args.AddRange(edgeLabels);
Bytecode.AddStep("inE", args.ToArray());
- return Wrap< S , Edge >(this);
+ return Wrap<S, Edge>(this);
}
/// <summary>
/// Adds the inV step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Vertex > InV ()
+ public GraphTraversal<S, Vertex> InV ()
{
Bytecode.AddStep("inV");
- return Wrap< S , Vertex >(this);
+ return Wrap<S, Vertex>(this);
}
/// <summary>
/// Adds the inject step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Inject (params E[] injections)
+ public GraphTraversal<S, E> Inject (params E[] injections)
{
- var args = new List< E >(0 + injections.Length) {};
+ var args = new List<E>(0 + injections.Length) {};
args.AddRange(injections);
Bytecode.AddStep("inject", args.ToArray());
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the is step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Is (object value)
+ public GraphTraversal<S, E> Is (object value)
{
Bytecode.AddStep("is", value);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the is step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Is (TraversalPredicate predicate)
+ public GraphTraversal<S, E> Is (TraversalPredicate predicate)
{
Bytecode.AddStep("is", predicate);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the key step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , string > Key ()
+ public GraphTraversal<S, string> Key ()
{
Bytecode.AddStep("key");
- return Wrap< S , string >(this);
+ return Wrap<S, string>(this);
}
/// <summary>
/// Adds the label step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , string > Label ()
+ public GraphTraversal<S, string> Label ()
{
Bytecode.AddStep("label");
- return Wrap< S , string >(this);
+ return Wrap<S, string>(this);
}
/// <summary>
/// Adds the limit step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Limit<E2> (Scope scope, long limit)
+ public GraphTraversal<S, E2> Limit<E2> (Scope scope, long limit)
{
Bytecode.AddStep("limit", scope, limit);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the limit step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Limit (long limit)
+ public GraphTraversal<S, E> Limit (long limit)
{
Bytecode.AddStep("limit", limit);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the local step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Local<E2> (ITraversal localTraversal)
+ public GraphTraversal<S, E2> Local<E2> (ITraversal localTraversal)
{
Bytecode.AddStep("local", localTraversal);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the loops step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , int > Loops ()
+ public GraphTraversal<S, int> Loops ()
{
Bytecode.AddStep("loops");
- return Wrap< S , int >(this);
+ return Wrap<S, int>(this);
}
/// <summary>
/// Adds the map step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Map<E2> (object function)
+ public GraphTraversal<S, E2> Map<E2> (object function)
{
Bytecode.AddStep("map", function);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the map step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Map<E2> (ITraversal mapTraversal)
+ public GraphTraversal<S, E2> Map<E2> (ITraversal mapTraversal)
{
Bytecode.AddStep("map", mapTraversal);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the mapKeys step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > MapKeys<E2> ()
+ public GraphTraversal<S, E2> MapKeys<E2> ()
{
Bytecode.AddStep("mapKeys");
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the mapValues step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > MapValues<E2> ()
+ public GraphTraversal<S, E2> MapValues<E2> ()
{
Bytecode.AddStep("mapValues");
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the match step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , IDictionary<string, E2> > Match<E2> (params ITraversal[] matchTraversals)
+ public GraphTraversal<S, IDictionary<string, E2>> Match<E2> (params ITraversal[] matchTraversals)
{
- var args = new List< object >(0 + matchTraversals.Length) {};
+ var args = new List<object>(0 + matchTraversals.Length) {};
args.AddRange(matchTraversals);
Bytecode.AddStep("match", args.ToArray());
- return Wrap< S , IDictionary<string, E2> >(this);
+ return Wrap<S, IDictionary<string, E2>>(this);
}
/// <summary>
/// Adds the max step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Max<E2> ()
+ public GraphTraversal<S, E2> Max<E2> ()
{
Bytecode.AddStep("max");
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the max step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Max<E2> (Scope scope)
+ public GraphTraversal<S, E2> Max<E2> (Scope scope)
{
Bytecode.AddStep("max", scope);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the mean step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Mean<E2> ()
+ public GraphTraversal<S, E2> Mean<E2> ()
{
Bytecode.AddStep("mean");
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the mean step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Mean<E2> (Scope scope)
+ public GraphTraversal<S, E2> Mean<E2> (Scope scope)
{
Bytecode.AddStep("mean", scope);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the min step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Min<E2> ()
+ public GraphTraversal<S, E2> Min<E2> ()
{
Bytecode.AddStep("min");
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the min step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Min<E2> (Scope scope)
+ public GraphTraversal<S, E2> Min<E2> (Scope scope)
{
Bytecode.AddStep("min", scope);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the not step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Not (ITraversal notTraversal)
+ public GraphTraversal<S, E> Not (ITraversal notTraversal)
{
Bytecode.AddStep("not", notTraversal);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the option step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Option (object pickToken, ITraversal traversalOption)
+ public GraphTraversal<S, E> Option (object pickToken, ITraversal traversalOption)
{
Bytecode.AddStep("option", pickToken, traversalOption);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the option step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Option (ITraversal traversalOption)
+ public GraphTraversal<S, E> Option (ITraversal traversalOption)
{
Bytecode.AddStep("option", traversalOption);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the optional step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Optional<E2> (ITraversal optionalTraversal)
+ public GraphTraversal<S, E2> Optional<E2> (ITraversal optionalTraversal)
{
Bytecode.AddStep("optional", optionalTraversal);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the or step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Or (params ITraversal[] orTraversals)
+ public GraphTraversal<S, E> Or (params ITraversal[] orTraversals)
{
- var args = new List< object >(0 + orTraversals.Length) {};
+ var args = new List<object>(0 + orTraversals.Length) {};
args.AddRange(orTraversals);
Bytecode.AddStep("or", args.ToArray());
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the order step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Order ()
+ public GraphTraversal<S, E> Order ()
{
Bytecode.AddStep("order");
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the order step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Order (Scope scope)
+ public GraphTraversal<S, E> Order (Scope scope)
{
Bytecode.AddStep("order", scope);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the otherV step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Vertex > OtherV ()
+ public GraphTraversal<S, Vertex> OtherV ()
{
Bytecode.AddStep("otherV");
- return Wrap< S , Vertex >(this);
+ return Wrap<S, Vertex>(this);
}
/// <summary>
/// Adds the out step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Vertex > Out (params string[] edgeLabels)
+ public GraphTraversal<S, Vertex> Out (params string[] edgeLabels)
{
- var args = new List< object >(0 + edgeLabels.Length) {};
+ var args = new List<object>(0 + edgeLabels.Length) {};
args.AddRange(edgeLabels);
Bytecode.AddStep("out", args.ToArray());
- return Wrap< S , Vertex >(this);
+ return Wrap<S, Vertex>(this);
}
/// <summary>
/// Adds the outE step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Edge > OutE (params string[] edgeLabels)
+ public GraphTraversal<S, Edge> OutE (params string[] edgeLabels)
{
- var args = new List< object >(0 + edgeLabels.Length) {};
+ var args = new List<object>(0 + edgeLabels.Length) {};
args.AddRange(edgeLabels);
Bytecode.AddStep("outE", args.ToArray());
- return Wrap< S , Edge >(this);
+ return Wrap<S, Edge>(this);
}
/// <summary>
/// Adds the outV step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Vertex > OutV ()
+ public GraphTraversal<S, Vertex> OutV ()
{
Bytecode.AddStep("outV");
- return Wrap< S , Vertex >(this);
+ return Wrap<S, Vertex>(this);
}
/// <summary>
/// Adds the pageRank step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > PageRank ()
+ public GraphTraversal<S, E> PageRank ()
{
Bytecode.AddStep("pageRank");
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the pageRank step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > PageRank (double alpha)
+ public GraphTraversal<S, E> PageRank (double alpha)
{
Bytecode.AddStep("pageRank", alpha);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the path step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Path > Path ()
+ public GraphTraversal<S, Path> Path ()
{
Bytecode.AddStep("path");
- return Wrap< S , Path >(this);
+ return Wrap<S, Path>(this);
}
/// <summary>
/// Adds the peerPressure step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > PeerPressure ()
+ public GraphTraversal<S, E> PeerPressure ()
{
Bytecode.AddStep("peerPressure");
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the profile step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Profile<E2> ()
+ public GraphTraversal<S, E2> Profile<E2> ()
{
Bytecode.AddStep("profile");
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the profile step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Profile (string sideEffectKey)
+ public GraphTraversal<S, E> Profile (string sideEffectKey)
{
Bytecode.AddStep("profile", sideEffectKey);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the program step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Program (object vertexProgram)
+ public GraphTraversal<S, E> Program (object vertexProgram)
{
Bytecode.AddStep("program", vertexProgram);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the project step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , IDictionary<string, E2> > Project<E2> (string projectKey, params string[] otherProjectKeys)
+ public GraphTraversal<S, IDictionary<string, E2>> Project<E2> (string projectKey, params string[] otherProjectKeys)
{
- var args = new List< object >(1 + otherProjectKeys.Length) {projectKey};
+ var args = new List<object>(1 + otherProjectKeys.Length) {projectKey};
args.AddRange(otherProjectKeys);
Bytecode.AddStep("project", args.ToArray());
- return Wrap< S , IDictionary<string, E2> >(this);
+ return Wrap<S, IDictionary<string, E2>>(this);
}
/// <summary>
/// Adds the properties step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Properties<E2> (params string[] propertyKeys)
+ public GraphTraversal<S, E2> Properties<E2> (params string[] propertyKeys)
{
- var args = new List< object >(0 + propertyKeys.Length) {};
+ var args = new List<object>(0 + propertyKeys.Length) {};
args.AddRange(propertyKeys);
Bytecode.AddStep("properties", args.ToArray());
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the property step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Property (Cardinality cardinality, object key, object value, params object[] keyValues)
+ public GraphTraversal<S, E> Property (Cardinality cardinality, object key, object value, params object[] keyValues)
{
- var args = new List< object >(3 + keyValues.Length) {cardinality, key, value};
+ var args = new List<object>(3 + keyValues.Length) {cardinality, key, value};
args.AddRange(keyValues);
Bytecode.AddStep("property", args.ToArray());
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the property step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Property (object key, object value, params object[] keyValues)
+ public GraphTraversal<S, E> Property (object key, object value, params object[] keyValues)
{
- var args = new List< object >(2 + keyValues.Length) {key, value};
+ var args = new List<object>(2 + keyValues.Length) {key, value};
args.AddRange(keyValues);
Bytecode.AddStep("property", args.ToArray());
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the propertyMap step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , IDictionary<string, E2> > PropertyMap<E2> (params string[] propertyKeys)
+ public GraphTraversal<S, IDictionary<string, E2>> PropertyMap<E2> (params string[] propertyKeys)
{
- var args = new List< object >(0 + propertyKeys.Length) {};
+ var args = new List<object>(0 + propertyKeys.Length) {};
args.AddRange(propertyKeys);
Bytecode.AddStep("propertyMap", args.ToArray());
- return Wrap< S , IDictionary<string, E2> >(this);
+ return Wrap<S, IDictionary<string, E2>>(this);
}
/// <summary>
/// Adds the range step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Range<E2> (Scope scope, long low, long high)
+ public GraphTraversal<S, E2> Range<E2> (Scope scope, long low, long high)
{
Bytecode.AddStep("range", scope, low, high);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the range step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Range (long low, long high)
+ public GraphTraversal<S, E> Range (long low, long high)
{
Bytecode.AddStep("range", low, high);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the repeat step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Repeat (ITraversal repeatTraversal)
+ public GraphTraversal<S, E> Repeat (ITraversal repeatTraversal)
{
Bytecode.AddStep("repeat", repeatTraversal);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the sack step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Sack<E2> ()
+ public GraphTraversal<S, E2> Sack<E2> ()
{
Bytecode.AddStep("sack");
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the sack step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Sack (object sackOperator)
+ public GraphTraversal<S, E> Sack (object sackOperator)
{
Bytecode.AddStep("sack", sackOperator);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the sack step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Sack (object sackOperator, string elementPropertyKey)
+ public GraphTraversal<S, E> Sack (object sackOperator, string elementPropertyKey)
{
Bytecode.AddStep("sack", sackOperator, elementPropertyKey);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the sample step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Sample (Scope scope, int amountToSample)
+ public GraphTraversal<S, E> Sample (Scope scope, int amountToSample)
{
Bytecode.AddStep("sample", scope, amountToSample);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the sample step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Sample (int amountToSample)
+ public GraphTraversal<S, E> Sample (int amountToSample)
{
Bytecode.AddStep("sample", amountToSample);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the select step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , ICollection<E2> > Select<E2> (Column column)
+ public GraphTraversal<S, ICollection<E2>> Select<E2> (Column column)
{
Bytecode.AddStep("select", column);
- return Wrap< S , ICollection<E2> >(this);
+ return Wrap<S, ICollection<E2>>(this);
}
/// <summary>
/// Adds the select step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Select<E2> (Pop pop, string selectKey)
+ public GraphTraversal<S, E2> Select<E2> (Pop pop, string selectKey)
{
Bytecode.AddStep("select", pop, selectKey);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the select step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , IDictionary<string, E2> > Select<E2> (Pop pop, string selectKey1, string selectKey2, params string[] otherSelectKeys)
+ public GraphTraversal<S, IDictionary<string, E2>> Select<E2> (Pop pop, string selectKey1, string selectKey2, params string[] otherSelectKeys)
{
- var args = new List< object >(3 + otherSelectKeys.Length) {pop, selectKey1, selectKey2};
+ var args = new List<object>(3 + otherSelectKeys.Length) {pop, selectKey1, selectKey2};
args.AddRange(otherSelectKeys);
Bytecode.AddStep("select", args.ToArray());
- return Wrap< S , IDictionary<string, E2> >(this);
+ return Wrap<S, IDictionary<string, E2>>(this);
}
/// <summary>
/// Adds the select step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Select<E2> (string selectKey)
+ public GraphTraversal<S, E2> Select<E2> (string selectKey)
{
Bytecode.AddStep("select", selectKey);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the select step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , IDictionary<string, E2> > Select<E2> (string selectKey1, string selectKey2, params string[] otherSelectKeys)
+ public GraphTraversal<S, IDictionary<string, E2>> Select<E2> (string selectKey1, string selectKey2, params string[] otherSelectKeys)
{
- var args = new List< object >(2 + otherSelectKeys.Length) {selectKey1, selectKey2};
+ var args = new List<object>(2 + otherSelectKeys.Length) {selectKey1, selectKey2};
args.AddRange(otherSelectKeys);
Bytecode.AddStep("select", args.ToArray());
- return Wrap< S , IDictionary<string, E2> >(this);
+ return Wrap<S, IDictionary<string, E2>>(this);
}
/// <summary>
/// Adds the sideEffect step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > SideEffect (object consumer)
+ public GraphTraversal<S, E> SideEffect (object consumer)
{
Bytecode.AddStep("sideEffect", consumer);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the sideEffect step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > SideEffect (ITraversal sideEffectTraversal)
+ public GraphTraversal<S, E> SideEffect (ITraversal sideEffectTraversal)
{
Bytecode.AddStep("sideEffect", sideEffectTraversal);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the simplePath step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > SimplePath ()
+ public GraphTraversal<S, E> SimplePath ()
{
Bytecode.AddStep("simplePath");
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the store step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Store (string sideEffectKey)
+ public GraphTraversal<S, E> Store (string sideEffectKey)
{
Bytecode.AddStep("store", sideEffectKey);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the subgraph step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Edge > Subgraph (string sideEffectKey)
+ public GraphTraversal<S, Edge> Subgraph (string sideEffectKey)
{
Bytecode.AddStep("subgraph", sideEffectKey);
- return Wrap< S , Edge >(this);
+ return Wrap<S, Edge>(this);
}
/// <summary>
/// Adds the sum step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Sum<E2> ()
+ public GraphTraversal<S, E2> Sum<E2> ()
{
Bytecode.AddStep("sum");
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the sum step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Sum<E2> (Scope scope)
+ public GraphTraversal<S, E2> Sum<E2> (Scope scope)
{
Bytecode.AddStep("sum", scope);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the tail step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Tail ()
+ public GraphTraversal<S, E> Tail ()
{
Bytecode.AddStep("tail");
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the tail step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Tail<E2> (Scope scope)
+ public GraphTraversal<S, E2> Tail<E2> (Scope scope)
{
Bytecode.AddStep("tail", scope);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the tail step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Tail<E2> (Scope scope, long limit)
+ public GraphTraversal<S, E2> Tail<E2> (Scope scope, long limit)
{
Bytecode.AddStep("tail", scope, limit);
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the tail step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Tail (long limit)
+ public GraphTraversal<S, E> Tail (long limit)
{
Bytecode.AddStep("tail", limit);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the timeLimit step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > TimeLimit (long timeLimit)
+ public GraphTraversal<S, E> TimeLimit (long timeLimit)
{
Bytecode.AddStep("timeLimit", timeLimit);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the times step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Times (int maxLoops)
+ public GraphTraversal<S, E> Times (int maxLoops)
{
Bytecode.AddStep("times", maxLoops);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the to step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Vertex > To (Direction direction, params string[] edgeLabels)
+ public GraphTraversal<S, Vertex> To (Direction direction, params string[] edgeLabels)
{
- var args = new List< object >(1 + edgeLabels.Length) {direction};
+ var args = new List<object>(1 + edgeLabels.Length) {direction};
args.AddRange(edgeLabels);
Bytecode.AddStep("to", args.ToArray());
- return Wrap< S , Vertex >(this);
+ return Wrap<S, Vertex>(this);
}
/// <summary>
/// Adds the to step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > To (string toStepLabel)
+ public GraphTraversal<S, E> To (string toStepLabel)
{
Bytecode.AddStep("to", toStepLabel);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the to step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > To (ITraversal toVertex)
+ public GraphTraversal<S, E> To (ITraversal toVertex)
{
Bytecode.AddStep("to", toVertex);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the toE step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Edge > ToE (Direction direction, params string[] edgeLabels)
+ public GraphTraversal<S, Edge> ToE (Direction direction, params string[] edgeLabels)
{
- var args = new List< object >(1 + edgeLabels.Length) {direction};
+ var args = new List<object>(1 + edgeLabels.Length) {direction};
args.AddRange(edgeLabels);
Bytecode.AddStep("toE", args.ToArray());
- return Wrap< S , Edge >(this);
+ return Wrap<S, Edge>(this);
}
/// <summary>
/// Adds the toV step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , Vertex > ToV (Direction direction)
+ public GraphTraversal<S, Vertex> ToV (Direction direction)
{
Bytecode.AddStep("toV", direction);
- return Wrap< S , Vertex >(this);
+ return Wrap<S, Vertex>(this);
}
/// <summary>
/// Adds the tree step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Tree<E2> ()
+ public GraphTraversal<S, E2> Tree<E2> ()
{
Bytecode.AddStep("tree");
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the tree step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Tree (string sideEffectKey)
+ public GraphTraversal<S, E> Tree (string sideEffectKey)
{
Bytecode.AddStep("tree", sideEffectKey);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the unfold step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Unfold<E2> ()
+ public GraphTraversal<S, E2> Unfold<E2> ()
{
Bytecode.AddStep("unfold");
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the union step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Union<E2> (params ITraversal[] unionTraversals)
+ public GraphTraversal<S, E2> Union<E2> (params ITraversal[] unionTraversals)
{
- var args = new List< object >(0 + unionTraversals.Length) {};
+ var args = new List<object>(0 + unionTraversals.Length) {};
args.AddRange(unionTraversals);
Bytecode.AddStep("union", args.ToArray());
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the until step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Until (TraversalPredicate untilPredicate)
+ public GraphTraversal<S, E> Until (TraversalPredicate untilPredicate)
{
Bytecode.AddStep("until", untilPredicate);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the until step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Until (ITraversal untilTraversal)
+ public GraphTraversal<S, E> Until (ITraversal untilTraversal)
{
Bytecode.AddStep("until", untilTraversal);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the value step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Value<E2> ()
+ public GraphTraversal<S, E2> Value<E2> ()
{
Bytecode.AddStep("value");
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the valueMap step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , IDictionary<string, E2> > ValueMap<E2> (params string[] propertyKeys)
+ public GraphTraversal<S, IDictionary<string, E2>> ValueMap<E2> (params string[] propertyKeys)
{
- var args = new List< object >(0 + propertyKeys.Length) {};
+ var args = new List<object>(0 + propertyKeys.Length) {};
args.AddRange(propertyKeys);
Bytecode.AddStep("valueMap", args.ToArray());
- return Wrap< S , IDictionary<string, E2> >(this);
+ return Wrap<S, IDictionary<string, E2>>(this);
}
/// <summary>
/// Adds the valueMap step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , IDictionary<string, E2> > ValueMap<E2> (bool includeTokens, params string[] propertyKeys)
+ public GraphTraversal<S, IDictionary<string, E2>> ValueMap<E2> (bool includeTokens, params string[] propertyKeys)
{
- var args = new List< object >(1 + propertyKeys.Length) {includeTokens};
+ var args = new List<object>(1 + propertyKeys.Length) {includeTokens};
args.AddRange(propertyKeys);
Bytecode.AddStep("valueMap", args.ToArray());
- return Wrap< S , IDictionary<string, E2> >(this);
+ return Wrap<S, IDictionary<string, E2>>(this);
}
/// <summary>
/// Adds the values step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E2 > Values<E2> (params string[] propertyKeys)
+ public GraphTraversal<S, E2> Values<E2> (params string[] propertyKeys)
{
- var args = new List< object >(0 + propertyKeys.Length) {};
+ var args = new List<object>(0 + propertyKeys.Length) {};
args.AddRange(propertyKeys);
Bytecode.AddStep("values", args.ToArray());
- return Wrap< S , E2 >(this);
+ return Wrap<S, E2>(this);
}
/// <summary>
/// Adds the where step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Where (TraversalPredicate predicate)
+ public GraphTraversal<S, E> Where (TraversalPredicate predicate)
{
Bytecode.AddStep("where", predicate);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the where step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Where (string startKey, TraversalPredicate predicate)
+ public GraphTraversal<S, E> Where (string startKey, TraversalPredicate predicate)
{
Bytecode.AddStep("where", startKey, predicate);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
/// <summary>
/// Adds the where step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
- public GraphTraversal< S , E > Where (ITraversal whereTraversal)
+ public GraphTraversal<S, E> Where (ITraversal whereTraversal)
{
Bytecode.AddStep("where", whereTraversal);
- return Wrap< S , E >(this);
+ return Wrap<S, E>(this);
}
}
http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/535b309e/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversalSource.cs
----------------------------------------------------------------------
diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversalSource.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversalSource.cs
index 880a0f5..2cbe4de 100644
--- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversalSource.cs
+++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversalSource.cs
@@ -187,10 +187,10 @@ namespace Gremlin.Net.Process.Traversal
/// Spawns a <see cref="GraphTraversal{SType, EType}" /> off this graph traversal source and adds the E step to that
/// traversal.
/// </summary>
- public GraphTraversal< Edge,Edge > E(params object[] edgesIds)
+ public GraphTraversal<Edge, Edge> E(params object[] edgesIds)
{
- var traversal = new GraphTraversal< Edge,Edge >(TraversalStrategies, new Bytecode(Bytecode));
- var args = new List< object >(0 + edgesIds.Length) {};
+ var traversal = new GraphTraversal<Edge, Edge>(TraversalStrategies, new Bytecode(Bytecode));
+ var args = new List<object>(0 + edgesIds.Length) {};
args.AddRange(edgesIds);
traversal.Bytecode.AddStep("E", args.ToArray());
return traversal;
@@ -200,10 +200,10 @@ namespace Gremlin.Net.Process.Traversal
/// Spawns a <see cref="GraphTraversal{SType, EType}" /> off this graph traversal source and adds the V step to that
/// traversal.
/// </summary>
- public GraphTraversal< Vertex,Vertex > V(params object[] vertexIds)
+ public GraphTraversal<Vertex, Vertex> V(params object[] vertexIds)
{
- var traversal = new GraphTraversal< Vertex,Vertex >(TraversalStrategies, new Bytecode(Bytecode));
- var args = new List< object >(0 + vertexIds.Length) {};
+ var traversal = new GraphTraversal<Vertex, Vertex>(TraversalStrategies, new Bytecode(Bytecode));
+ var args = new List<object>(0 + vertexIds.Length) {};
args.AddRange(vertexIds);
traversal.Bytecode.AddStep("V", args.ToArray());
return traversal;
@@ -213,9 +213,9 @@ namespace Gremlin.Net.Process.Traversal
/// Spawns a <see cref="GraphTraversal{SType, EType}" /> off this graph traversal source and adds the addV step to that
/// traversal.
/// </summary>
- public GraphTraversal< Vertex,Vertex > AddV()
+ public GraphTraversal<Vertex, Vertex> AddV()
{
- var traversal = new GraphTraversal< Vertex,Vertex >(TraversalStrategies, new Bytecode(Bytecode));
+ var traversal = new GraphTraversal<Vertex, Vertex>(TraversalStrategies, new Bytecode(Bytecode));
traversal.Bytecode.AddStep("addV");
return traversal;
}
@@ -224,10 +224,10 @@ namespace Gremlin.Net.Process.Traversal
/// Spawns a <see cref="GraphTraversal{SType, EType}" /> off this graph traversal source and adds the addV step to that
/// traversal.
/// </summary>
- public GraphTraversal< Vertex,Vertex > AddV(params object[] keyValues)
+ public GraphTraversal<Vertex, Vertex> AddV(params object[] keyValues)
{
- var traversal = new GraphTraversal< Vertex,Vertex >(TraversalStrategies, new Bytecode(Bytecode));
- var args = new List< object >(0 + keyValues.Length) {};
+ var traversal = new GraphTraversal<Vertex, Vertex>(TraversalStrategies, new Bytecode(Bytecode));
+ var args = new List<object>(0 + keyValues.Length) {};
args.AddRange(keyValues);
traversal.Bytecode.AddStep("addV", args.ToArray());
return traversal;
@@ -237,9 +237,9 @@ namespace Gremlin.Net.Process.Traversal
/// Spawns a <see cref="GraphTraversal{SType, EType}" /> off this graph traversal source and adds the addV step to that
/// traversal.
/// </summary>
- public GraphTraversal< Vertex,Vertex > AddV(string label)
+ public GraphTraversal<Vertex, Vertex> AddV(string label)
{
- var traversal = new GraphTraversal< Vertex,Vertex >(TraversalStrategies, new Bytecode(Bytecode));
+ var traversal = new GraphTraversal<Vertex, Vertex>(TraversalStrategies, new Bytecode(Bytecode));
traversal.Bytecode.AddStep("addV", label);
return traversal;
}
@@ -248,10 +248,10 @@ namespace Gremlin.Net.Process.Traversal
/// Spawns a <see cref="GraphTraversal{SType, EType}" /> off this graph traversal source and adds the inject step to that
/// traversal.
/// </summary>
- public GraphTraversal< S,S > Inject<S>(params S[] starts)
+ public GraphTraversal<S, S> Inject<S>(params S[] starts)
{
- var traversal = new GraphTraversal< S,S >(TraversalStrategies, new Bytecode(Bytecode));
- var args = new List< S >(0 + starts.Length) {};
+ var traversal = new GraphTraversal<S, S>(TraversalStrategies, new Bytecode(Bytecode));
+ var args = new List<S>(0 + starts.Length) {};
args.AddRange(starts);
traversal.Bytecode.AddStep("inject", args.ToArray());
return traversal;