From 027524afce7fd239cc7db600ba1fd0b5f005e46e Mon Sep 17 00:00:00 2001 From: Jorge Bay Gondra Date: Wed, 31 May 2017 17:19:55 +0200 Subject: [PATCH] C# GLV: Generics and enum generation --- .../dotnet/AnonymousTraversalGenerator.groovy | 53 ++- .../gremlin/dotnet/EnumGenerator.groovy | 60 ++- .../dotnet/GraphTraversalGenerator.groovy | 40 +- .../GraphTraversalSourceGenerator.groovy | 33 +- .../gremlin/dotnet/PredicateGenerator.groovy | 3 +- .../gremlin/dotnet/SymbolHelper.groovy | 58 +++ .../Driver/Remote/DriverRemoteConnection.cs | 4 +- .../Driver/Remote/DriverRemoteTraversal.cs | 2 +- .../Process/Remote/IRemoteConnection.cs | 2 +- .../Process/Remote/RemoteStrategy.cs | 6 +- .../Gremlin.Net/Process/Traversal/Barrier.cs | 2 +- .../Process/Traversal/Cardinality.cs | 6 +- .../Gremlin.Net/Process/Traversal/Column.cs | 4 +- .../Process/Traversal/DefaultTraversal.cs | 23 +- .../Process/Traversal/Direction.cs | 6 +- .../Process/Traversal/GraphTraversal.cs | 408 +++++++++--------- .../Process/Traversal/GraphTraversalSource.cs | 22 +- .../Process/Traversal/ITraversal.cs | 27 +- .../Process/Traversal/ITraversalStrategy.cs | 4 +- .../Process/Traversal/NamingConversions.cs | 86 ++++ .../Gremlin.Net/Process/Traversal/Operator.cs | 22 +- .../Gremlin.Net/Process/Traversal/Order.cs | 14 +- .../src/Gremlin.Net/Process/Traversal/P.cs | 2 +- .../src/Gremlin.Net/Process/Traversal/Pick.cs | 4 +- .../src/Gremlin.Net/Process/Traversal/Pop.cs | 6 +- .../Gremlin.Net/Process/Traversal/Scope.cs | 4 +- .../Strategy/AbstractTraversalStrategy.cs | 4 +- .../src/Gremlin.Net/Process/Traversal/T.cs | 8 +- .../src/Gremlin.Net/Process/Traversal/__.cs | 373 ++++++++-------- .../Structure/IO/GraphSON/EnumSerializer.cs | 5 +- .../Process/Remote/RemoteStrategyTests.cs | 6 +- .../BytecodeGeneration/StrategiesTests.cs | 6 +- .../DriverRemoteConnection/EnumTests.cs | 6 +- .../GraphTraversalSourceTests.cs | 4 +- .../GraphTraversalTests.cs | 13 +- .../DriverRemoteConnection/SideEffectTests.cs | 4 +- .../DriverRemoteConnection/StrategiesTests.cs | 6 +- .../Process/Traversal/TestTraversal.cs | 4 +- .../Traversal/TestTraversalStrategy.cs | 6 +- .../BytecodeGraphSONSerializerTests.cs | 4 +- .../IO/GraphSON/GraphSONWriterTests.cs | 9 +- 41 files changed, 808 insertions(+), 551 deletions(-) create mode 100644 gremlin-dotnet/src/Gremlin.Net/Process/Traversal/NamingConversions.cs diff --git a/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/AnonymousTraversalGenerator.groovy b/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/AnonymousTraversalGenerator.groovy index ca5fadb0e6d..b65b2b0450d 100644 --- a/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/AnonymousTraversalGenerator.groovy +++ b/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/AnonymousTraversalGenerator.groovy @@ -26,43 +26,70 @@ import java.lang.reflect.Modifier class AnonymousTraversalGenerator { + private static final Map METHODS_WITH_SPECIFIC_TYPES = new HashMap<>(); + + static { + String[] useE2 = ["E2", "E2"]; + METHODS_WITH_SPECIFIC_TYPES.put("constant", useE2); + METHODS_WITH_SPECIFIC_TYPES.put("limit", useE2); + METHODS_WITH_SPECIFIC_TYPES.put("mean", useE2); + METHODS_WITH_SPECIFIC_TYPES.put("optional", useE2); + METHODS_WITH_SPECIFIC_TYPES.put("range", useE2); + METHODS_WITH_SPECIFIC_TYPES.put("select", ["IDictionary", "E2"] as String[]); + METHODS_WITH_SPECIFIC_TYPES.put("sum", useE2); + METHODS_WITH_SPECIFIC_TYPES.put("tail", useE2); + METHODS_WITH_SPECIFIC_TYPES.put("tree", ["object"] as String[]); + METHODS_WITH_SPECIFIC_TYPES.put("unfold", useE2); + } + public static void create(final String anonymousTraversalFile) { + final StringBuilder csharpClass = new StringBuilder() csharpClass.append(CommonContentHelper.getLicense()) csharpClass.append( """ +using System.Collections.Generic; +using Gremlin.Net.Structure; + namespace Gremlin.Net.Process.Traversal { public static class __ { - public static GraphTraversal Start() + public static GraphTraversal Start() { - return new GraphTraversal(); + return new GraphTraversal(); } """) __.getMethods(). findAll { GraphTraversal.class.equals(it.returnType) }. findAll { Modifier.isStatic(it.getModifiers()) }. - collect { it.name }. - findAll { !it.equals("__") && !it.equals("start") }. - unique(). - sort { a, b -> a <=> b }. - forEach { javaMethodName -> - String sharpMethodName = SymbolHelper.toCSharp(javaMethodName) - + findAll { !it.name.equals("__") && !it.name.equals("start") }. + groupBy { it.name }. + // Select unique by name, with the most amount of parameters + collect { it.value.sort { a, b -> b.parameterCount <=> a.parameterCount }.first() }. + sort { it.name }. + forEach { javaMethod -> + String sharpMethodName = SymbolHelper.toCSharp(javaMethod.name); + String[] typeNames = SymbolHelper.getJavaParameterTypeNames(javaMethod); + def t2 = SymbolHelper.toCSharpType(typeNames[1]); + def tParam = SymbolHelper.getCSharpGenericTypeParam(t2); + def specificTypes = METHODS_WITH_SPECIFIC_TYPES.get(javaMethod.name); + if (specificTypes) { + t2 = specificTypes[0]; + tParam = specificTypes.length > 1 ? "<" + specificTypes[1] + ">" : ""; + } csharpClass.append( """ - public static GraphTraversal ${sharpMethodName}(params object[] args) + public static GraphTraversal $sharpMethodName$tParam(params object[] args) { - return new GraphTraversal().${sharpMethodName}(args); + return new GraphTraversal().$sharpMethodName$tParam(args); } """) } - csharpClass.append("\t}\n") - csharpClass.append("}") + csharpClass.append(" }\n}") final File file = new File(anonymousTraversalFile); file.delete() diff --git a/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/EnumGenerator.groovy b/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/EnumGenerator.groovy index 799e0010821..840b604dbca 100644 --- a/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/EnumGenerator.groovy +++ b/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/EnumGenerator.groovy @@ -20,20 +20,66 @@ package org.apache.tinkerpop.gremlin.dotnet import org.apache.tinkerpop.gremlin.util.CoreImports +import org.apache.tinkerpop.gremlin.structure.Direction class EnumGenerator { public static void create(final String enumDirectory) { + Map enumCSharpToJavaNames = new HashMap(); for (final Class enumClass : CoreImports.getClassImports() .findAll { Enum.class.isAssignableFrom(it) } .sort { a, b -> a.getSimpleName() <=> b.getSimpleName() } .collect()) { - createEnum(enumDirectory, enumClass) + createEnum(enumDirectory, enumClass, enumCSharpToJavaNames) } + + // Write a file containing the equivalence in names between Java and C# + final String enumCSharpToJavaFile = "$enumDirectory/NamingConversions.cs" + final File file = new File(enumCSharpToJavaFile); + file.delete(); + file.append(CommonContentHelper.getLicense()); + file.append(""" +using System.Collections.Generic; + +namespace Gremlin.Net.Process.Traversal +{ + internal static class NamingConversions + { + /// + /// Gets the Java name equivalent for a given enum value + /// + internal static string GetEnumJavaName(string typeName, string value) + { + var key = \$"{typeName}.{value}"; + string javaName; + if (!CSharpToJavaEnums.TryGetValue(key, out javaName)) + { + throw new KeyNotFoundException(\$"Java name for {key} not found"); + } + return javaName; + } + + internal static readonly IDictionary CSharpToJavaEnums = new Dictionary + { +""" ); + def lastIndex = (enumCSharpToJavaNames.size() - 1); + enumCSharpToJavaNames.eachWithIndex{ node, i -> + file.append(""" {"$node.key", "$node.value"}${i == lastIndex ? "" : ","}\n""") + } + file.append(" };\n }\n}"); + + } + + public static String toCSharpName(final Class enumClass, String itemName) { + if (enumClass.equals(Direction.class)) { + itemName = itemName.toLowerCase(); + } + return itemName.substring(0, 1).toUpperCase() + itemName.substring(1); } - private static void createEnum(final String enumDirectory, final Class enumClass){ + private static void createEnum(final String enumDirectory, final Class enumClass, + final Map csharpToJava) { final StringBuilder csharpEnum = new StringBuilder() csharpEnum.append(CommonContentHelper.getLicense()) @@ -45,9 +91,13 @@ namespace Gremlin.Net.Process.Traversal public enum ${enumClass.getSimpleName()} { """) - enumClass.getEnumConstants() - .sort { a, b -> a.name() <=> b.name() } - .each { value -> csharpEnum.append(" ${value.name()},\n"); } + enumClass.getEnumConstants(). + sort { a, b -> a.name() <=> b.name() }. + each { value -> + def csharpName = toCSharpName(enumClass, value.name()); + csharpEnum.append(" $csharpName,\n"); + csharpToJava.put(enumClass.simpleName + "." + csharpName, value.name()); + } csharpEnum.deleteCharAt(csharpEnum.length() - 2) csharpEnum.append(" }\n") diff --git a/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/GraphTraversalGenerator.groovy b/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/GraphTraversalGenerator.groovy index 58a399110fb..d3bade53a26 100644 --- a/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/GraphTraversalGenerator.groovy +++ b/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/GraphTraversalGenerator.groovy @@ -32,10 +32,11 @@ class GraphTraversalGenerator { csharpClass.append( """ using System.Collections.Generic; +using Gremlin.Net.Structure; namespace Gremlin.Net.Process.Traversal { - public class GraphTraversal : DefaultTraversal + public class GraphTraversal : DefaultTraversal { public GraphTraversal() : this(new List(), new Bytecode()) @@ -47,27 +48,40 @@ namespace Gremlin.Net.Process.Traversal TraversalStrategies = traversalStrategies; Bytecode = bytecode; } + + private static GraphTraversal Wrap(GraphTraversal traversal) + { + if (typeof(S2) == typeof(S) && typeof(E2) == typeof(E)) + { + return traversal as GraphTraversal; + } + // New wrapper + return new GraphTraversal(traversal.TraversalStrategies, traversal.Bytecode); + } + """) GraphTraversal.getMethods(). findAll { GraphTraversal.class.equals(it.returnType) }. findAll { !it.name.equals("clone") && !it.name.equals("iterate") }. - collect { it.name }. - unique(). - sort { a, b -> a <=> b }. - forEach { javaMethodName -> - String sharpMethodName = SymbolHelper.toCSharp(javaMethodName) - + groupBy { it.name }. + // Select unique by name, with the most amount of parameters + collect { it.value.sort { a, b -> b.parameterCount <=> a.parameterCount }.first() }. + sort { it.name }. + forEach { javaMethod -> + String[] typeNames = SymbolHelper.getJavaParameterTypeNames(javaMethod); + def t1 = SymbolHelper.toCSharpType(typeNames[0]); + def t2 = SymbolHelper.toCSharpType(typeNames[1]); + def tParam = SymbolHelper.getCSharpGenericTypeParam(t2); csharpClass.append( - """ - public GraphTraversal ${sharpMethodName}(params object[] args) +""" + public GraphTraversal<$t1, $t2> ${SymbolHelper.toCSharp(javaMethod.name)}$tParam(params object[] args) { - Bytecode.AddStep("${javaMethodName}", args); - return this; + Bytecode.AddStep("$javaMethod.name", args); + return Wrap<$t1, $t2>(this); } """) } - csharpClass.append("\t}\n") - csharpClass.append("}") + csharpClass.append(" }\n}") final File file = new File(graphTraversalFile); file.delete() diff --git a/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/GraphTraversalSourceGenerator.groovy b/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/GraphTraversalSourceGenerator.groovy index fce4b70a6a9..7cb41da67a9 100644 --- a/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/GraphTraversalSourceGenerator.groovy +++ b/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/GraphTraversalSourceGenerator.groovy @@ -21,7 +21,7 @@ package org.apache.tinkerpop.gremlin.dotnet import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource - +import java.lang.reflect.* class GraphTraversalSourceGenerator { @@ -36,6 +36,7 @@ class GraphTraversalSourceGenerator { using System.Collections.Generic; using Gremlin.Net.Process.Remote; using Gremlin.Net.Process.Traversal.Strategy.Decoration; +using Gremlin.Net.Structure; namespace Gremlin.Net.Process.Traversal { @@ -57,9 +58,6 @@ namespace Gremlin.Net.Process.Traversal """ ) - // Hold the list of methods with their overloads, so we do not create duplicates - HashMap> sharpMethods = new HashMap>() - GraphTraversalSource.getMethods(). // SOURCE STEPS findAll { GraphTraversalSource.class.equals(it.returnType) }. findAll { @@ -110,27 +108,32 @@ namespace Gremlin.Net.Process.Traversal } """) - GraphTraversalSource.getMethods(). // SPAWN STEPS + GraphTraversalSource.getMethods(). findAll { GraphTraversal.class.equals(it.returnType) }. - collect { it.name }. - unique(). - sort { a, b -> a <=> b }. - forEach { javaMethodName -> - String sharpMethodName = SymbolHelper.toCSharp(javaMethodName) + unique{ a -> a.name }. + sort { a, b -> a.name <=> b.name }. + forEach { javaMethod -> + String sharpMethodName = SymbolHelper.toCSharp(javaMethod.name); + Type[] typeArguments = ((ParameterizedType)javaMethod.getGenericReturnType()).actualTypeArguments; + if (typeArguments.length != 2 || !(typeArguments[0] instanceof Class)) { + return; + } + def returnType = """GraphTraversal<${ + ((Class)typeArguments[0]).getSimpleName()}, ${((Class)typeArguments[1]).getSimpleName()}>"""; + csharpClass.append( """ - public GraphTraversal ${sharpMethodName}(params object[] args) + public ${returnType} ${sharpMethodName}(params object[] args) { - var traversal = new GraphTraversal(TraversalStrategies, new Bytecode(Bytecode)); - traversal.Bytecode.AddStep("${javaMethodName}\", args); + var traversal = new ${returnType}(TraversalStrategies, new Bytecode(Bytecode)); + traversal.Bytecode.AddStep("${javaMethod.name}\", args); return traversal; } """) } - csharpClass.append("\t}\n") - csharpClass.append("}") + csharpClass.append(" }\n}") final File file = new File(graphTraversalSourceFile); file.delete() diff --git a/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/PredicateGenerator.groovy b/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/PredicateGenerator.groovy index 2633de6e498..c5c9c10906b 100644 --- a/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/PredicateGenerator.groovy +++ b/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/PredicateGenerator.groovy @@ -55,8 +55,7 @@ namespace Gremlin.Net.Process.Traversal } """) } - csharpClass.append("\t}\n") - csharpClass.append("}") + csharpClass.append(" }\n}") final File file = new File(predicateFile) file.delete() diff --git a/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/SymbolHelper.groovy b/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/SymbolHelper.groovy index 6c237e8e394..c041062cbe7 100644 --- a/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/SymbolHelper.groovy +++ b/gremlin-dotnet-generator/src/main/groovy/org/apache/tinkerpop/gremlin/dotnet/SymbolHelper.groovy @@ -19,8 +19,29 @@ package org.apache.tinkerpop.gremlin.dotnet +import java.lang.reflect.Method; +import java.lang.reflect.ParameterizedType; + public final class SymbolHelper { + private static final Map TO_CSHARP_TYPE_MAP = new HashMap<>(); + + static { + TO_CSHARP_TYPE_MAP.put("Long", "long"); + TO_CSHARP_TYPE_MAP.put("Integer", "int"); + TO_CSHARP_TYPE_MAP.put("String", "string"); + TO_CSHARP_TYPE_MAP.put("Object", "object"); + TO_CSHARP_TYPE_MAP.put("java.util.Map", "IDictionary"); + TO_CSHARP_TYPE_MAP.put("java.util.Map", "IDictionary") + TO_CSHARP_TYPE_MAP.put("java.util.List", "IList"); + TO_CSHARP_TYPE_MAP.put("java.util.List", "IList"); + TO_CSHARP_TYPE_MAP.put("java.util.Map", "IDictionary"); + TO_CSHARP_TYPE_MAP.put("java.util.Collection", "ICollection"); + TO_CSHARP_TYPE_MAP.put("java.util.Collection", "ICollection") + TO_CSHARP_TYPE_MAP.put("java.util.Map", "IDictionary"); + TO_CSHARP_TYPE_MAP.put("TraversalMetrics", "E2"); + } + public static String toCSharp(final String symbol) { return (String) Character.toUpperCase(symbol.charAt(0)) + symbol.substring(1) } @@ -28,4 +49,41 @@ public final class SymbolHelper { public static String toJava(final String symbol) { return (String) Character.toLowerCase(symbol.charAt(0)) + symbol.substring(1) } + + public static String toCSharpType(final String name) { + String typeName = TO_CSHARP_TYPE_MAP.getOrDefault(name, name); + if (typeName.equals(name) && (typeName.contains("? extends") || typeName.equals("Tree"))) { + typeName = "E2"; + } + return typeName; + } + + public static String[] getJavaParameterTypeNames(final Method method) { + def typeArguments = ((ParameterizedType)method.genericReturnType).actualTypeArguments; + return typeArguments. + collect { (it instanceof Class) ? ((Class)it).simpleName : it.typeName }. + collect { name -> + if (name.equals("A")) { + name = "object"; + } + else if (name.equals("B")) { + name = "E2"; + } + name; + }; + } + + public static String getCSharpGenericTypeParam(String typeName) { + def tParam = ""; + if (typeName.contains("E2")) { + tParam = ""; + } + else if (typeName.contains("")) { + tParam = ""; + } + else if (typeName.contains(" /// The to submit. /// A allowing to access the results and side-effects. - public async Task SubmitAsync(Bytecode bytecode) + public async Task> SubmitAsync(Bytecode bytecode) { var requestId = Guid.NewGuid(); var resultSet = await SubmitBytecodeAsync(requestId, bytecode).ConfigureAwait(false); - return new DriverRemoteTraversal(_client, requestId, resultSet); + return new DriverRemoteTraversal(_client, requestId, resultSet); } private async Task> SubmitBytecodeAsync(Guid requestid, Bytecode bytecode) diff --git a/gremlin-dotnet/src/Gremlin.Net/Driver/Remote/DriverRemoteTraversal.cs b/gremlin-dotnet/src/Gremlin.Net/Driver/Remote/DriverRemoteTraversal.cs index f3f26d17ae6..5ce835fcb27 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Driver/Remote/DriverRemoteTraversal.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Driver/Remote/DriverRemoteTraversal.cs @@ -27,7 +27,7 @@ namespace Gremlin.Net.Driver.Remote { - internal class DriverRemoteTraversal : DefaultTraversal + internal class DriverRemoteTraversal : DefaultTraversal { public DriverRemoteTraversal(IGremlinClient gremlinClient, Guid requestId, IEnumerable traversers) diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Remote/IRemoteConnection.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Remote/IRemoteConnection.cs index 8555cb3d96e..5393bcbd19f 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Remote/IRemoteConnection.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Remote/IRemoteConnection.cs @@ -37,6 +37,6 @@ public interface IRemoteConnection /// /// The to send. /// The with the results and optional side-effects. - Task SubmitAsync(Bytecode bytecode); + Task> SubmitAsync(Bytecode bytecode); } } \ No newline at end of file diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Remote/RemoteStrategy.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Remote/RemoteStrategy.cs index 4826113444e..b3f8c4426d9 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Remote/RemoteStrategy.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Remote/RemoteStrategy.cs @@ -44,16 +44,16 @@ public RemoteStrategy(IRemoteConnection remoteConnection) } /// - public void Apply(ITraversal traversal) + public void Apply(ITraversal traversal) { ApplyAsync(traversal).Wait(); } /// - public async Task ApplyAsync(ITraversal traversal) + public async Task ApplyAsync(ITraversal traversal) { if (traversal.Traversers != null) return; - var remoteTraversal = await _remoteConnection.SubmitAsync(traversal.Bytecode).ConfigureAwait(false); + var remoteTraversal = await _remoteConnection.SubmitAsync(traversal.Bytecode).ConfigureAwait(false); traversal.SideEffects = remoteTraversal.SideEffects; traversal.Traversers = remoteTraversal.Traversers; } diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Barrier.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Barrier.cs index 13d179649a8..6ef1d4f41c3 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Barrier.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Barrier.cs @@ -25,6 +25,6 @@ namespace Gremlin.Net.Process.Traversal { public enum Barrier { - normSack + NormSack } } diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Cardinality.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Cardinality.cs index f2365c32b54..b158d09a8a4 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Cardinality.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Cardinality.cs @@ -25,8 +25,8 @@ namespace Gremlin.Net.Process.Traversal { public enum Cardinality { - list, - set, - single + List, + Set, + Single } } diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Column.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Column.cs index ee591dad95e..0f3556c11f2 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Column.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Column.cs @@ -25,7 +25,7 @@ namespace Gremlin.Net.Process.Traversal { public enum Column { - keys, - values + Keys, + Values } } diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/DefaultTraversal.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/DefaultTraversal.cs index 86c636ce61e..2652df3a508 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/DefaultTraversal.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/DefaultTraversal.cs @@ -22,6 +22,7 @@ #endregion using System; +using System.Collections; using System.Collections.Generic; using System.Threading.Tasks; @@ -30,7 +31,7 @@ namespace Gremlin.Net.Process.Traversal /// /// A traversal represents a directed walk over a graph. /// - public abstract class DefaultTraversal : ITraversal + public abstract class DefaultTraversal : ITraversal { private IEnumerator _traverserEnumerator; @@ -85,7 +86,9 @@ public void Reset() } /// - public object Current => TraverserEnumerator.Current?.Object; + public E Current => (E)TraverserEnumerator.Current?.Object; + + object IEnumerator.Current => Current; private IEnumerator GetTraverserEnumerator() { @@ -110,7 +113,7 @@ private async Task ApplyStrategiesAsync() /// Gets the next result from the traversal. /// /// The result. - public object Next() + public E Next() { MoveNext(); return Current; @@ -121,7 +124,7 @@ public object Next() /// /// The number of results to get. /// The n-results. - public IEnumerable Next(int amount) + public IEnumerable Next(int amount) { for (var i = 0; i < amount; i++) yield return Next(); @@ -131,7 +134,7 @@ public IEnumerable Next(int amount) /// Iterates all instances in the traversal. /// /// The fully drained traversal. - public ITraversal Iterate() + public ITraversal Iterate() { while (MoveNext()) { @@ -153,9 +156,9 @@ public Traverser NextTraverser() /// Puts all the results into a . /// /// The results in a list. - public List ToList() + public IList ToList() { - var objs = new List(); + var objs = new List(); while (MoveNext()) objs.Add(Current); return objs; @@ -165,9 +168,9 @@ public List ToList() /// Puts all the results into a . /// /// The results in a set. - public HashSet ToSet() + public ISet ToSet() { - var objs = new HashSet(); + var objs = new HashSet(); while (MoveNext()) objs.Add(Current); return objs; @@ -186,7 +189,7 @@ protected virtual void Dispose(bool disposing) /// The return type of the . /// The function to execute on the current traversal. /// The result of the executed . - public async Task Promise(Func callback) + public async Task Promise(Func, TReturn> callback) { await ApplyStrategiesAsync().ConfigureAwait(false); return callback(this); diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Direction.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Direction.cs index 413e11feafc..100296cf0f8 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Direction.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Direction.cs @@ -25,8 +25,8 @@ namespace Gremlin.Net.Process.Traversal { public enum Direction { - BOTH, - IN, - OUT + Both, + In, + Out } } diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversal.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversal.cs index 88e9261d273..0f3fbb70f9f 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversal.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversal.cs @@ -22,10 +22,11 @@ #endregion using System.Collections.Generic; +using Gremlin.Net.Structure; namespace Gremlin.Net.Process.Traversal { - public class GraphTraversal : DefaultTraversal + public class GraphTraversal : DefaultTraversal { public GraphTraversal() : this(new List(), new Bytecode()) @@ -38,592 +39,603 @@ public GraphTraversal(ICollection traversalStrategies, Bytec Bytecode = bytecode; } - public GraphTraversal V(params object[] args) + private static GraphTraversal Wrap(GraphTraversal traversal) + { + if (typeof(S2) == typeof(S) && typeof(E2) == typeof(E)) + { + return traversal as GraphTraversal; + } + // New wrapper + return new GraphTraversal(traversal.TraversalStrategies, traversal.Bytecode); + } + + + public GraphTraversal V(params object[] args) { Bytecode.AddStep("V", args); - return this; + return Wrap(this); } - public GraphTraversal AddE(params object[] args) + public GraphTraversal AddE(params object[] args) { Bytecode.AddStep("addE", args); - return this; + return Wrap(this); } - public GraphTraversal AddInE(params object[] args) + public GraphTraversal AddInE(params object[] args) { Bytecode.AddStep("addInE", args); - return this; + return Wrap(this); } - public GraphTraversal AddOutE(params object[] args) + public GraphTraversal AddOutE(params object[] args) { Bytecode.AddStep("addOutE", args); - return this; + return Wrap(this); } - public GraphTraversal AddV(params object[] args) + public GraphTraversal AddV(params object[] args) { Bytecode.AddStep("addV", args); - return this; + return Wrap(this); } - public GraphTraversal Aggregate(params object[] args) + public GraphTraversal Aggregate(params object[] args) { Bytecode.AddStep("aggregate", args); - return this; + return Wrap(this); } - public GraphTraversal And(params object[] args) + public GraphTraversal And(params object[] args) { Bytecode.AddStep("and", args); - return this; + return Wrap(this); } - public GraphTraversal As(params object[] args) + public GraphTraversal As(params object[] args) { Bytecode.AddStep("as", args); - return this; + return Wrap(this); } - public GraphTraversal Barrier(params object[] args) + public GraphTraversal Barrier(params object[] args) { Bytecode.AddStep("barrier", args); - return this; + return Wrap(this); } - public GraphTraversal Both(params object[] args) + public GraphTraversal Both(params object[] args) { Bytecode.AddStep("both", args); - return this; + return Wrap(this); } - public GraphTraversal BothE(params object[] args) + public GraphTraversal BothE(params object[] args) { Bytecode.AddStep("bothE", args); - return this; + return Wrap(this); } - public GraphTraversal BothV(params object[] args) + public GraphTraversal BothV(params object[] args) { Bytecode.AddStep("bothV", args); - return this; + return Wrap(this); } - public GraphTraversal Branch(params object[] args) + public GraphTraversal Branch(params object[] args) { Bytecode.AddStep("branch", args); - return this; + return Wrap(this); } - public GraphTraversal By(params object[] args) + public GraphTraversal By(params object[] args) { Bytecode.AddStep("by", args); - return this; + return Wrap(this); } - public GraphTraversal Cap(params object[] args) + public GraphTraversal Cap(params object[] args) { Bytecode.AddStep("cap", args); - return this; + return Wrap(this); } - public GraphTraversal Choose(params object[] args) + public GraphTraversal Choose(params object[] args) { Bytecode.AddStep("choose", args); - return this; + return Wrap(this); } - public GraphTraversal Coalesce(params object[] args) + public GraphTraversal Coalesce(params object[] args) { Bytecode.AddStep("coalesce", args); - return this; + return Wrap(this); } - public GraphTraversal Coin(params object[] args) + public GraphTraversal Coin(params object[] args) { Bytecode.AddStep("coin", args); - return this; + return Wrap(this); } - public GraphTraversal Constant(params object[] args) + public GraphTraversal Constant(params object[] args) { Bytecode.AddStep("constant", args); - return this; + return Wrap(this); } - public GraphTraversal Count(params object[] args) + public GraphTraversal Count(params object[] args) { Bytecode.AddStep("count", args); - return this; + return Wrap(this); } - public GraphTraversal CyclicPath(params object[] args) + public GraphTraversal CyclicPath(params object[] args) { Bytecode.AddStep("cyclicPath", args); - return this; + return Wrap(this); } - public GraphTraversal Dedup(params object[] args) + public GraphTraversal Dedup(params object[] args) { Bytecode.AddStep("dedup", args); - return this; + return Wrap(this); } - public GraphTraversal Drop(params object[] args) + public GraphTraversal Drop(params object[] args) { Bytecode.AddStep("drop", args); - return this; + return Wrap(this); } - public GraphTraversal Emit(params object[] args) + public GraphTraversal Emit(params object[] args) { Bytecode.AddStep("emit", args); - return this; + return Wrap(this); } - public GraphTraversal Filter(params object[] args) + public GraphTraversal Filter(params object[] args) { Bytecode.AddStep("filter", args); - return this; + return Wrap(this); } - public GraphTraversal FlatMap(params object[] args) + public GraphTraversal FlatMap(params object[] args) { Bytecode.AddStep("flatMap", args); - return this; + return Wrap(this); } - public GraphTraversal Fold(params object[] args) + public GraphTraversal Fold(params object[] args) { Bytecode.AddStep("fold", args); - return this; + return Wrap(this); } - public GraphTraversal From(params object[] args) + public GraphTraversal From(params object[] args) { Bytecode.AddStep("from", args); - return this; + return Wrap(this); } - public GraphTraversal Group(params object[] args) + public GraphTraversal Group(params object[] args) { Bytecode.AddStep("group", args); - return this; + return Wrap(this); } - public GraphTraversal GroupCount(params object[] args) + public GraphTraversal GroupCount(params object[] args) { Bytecode.AddStep("groupCount", args); - return this; + return Wrap(this); } - public GraphTraversal GroupV3d0(params object[] args) + public GraphTraversal GroupV3d0(params object[] args) { Bytecode.AddStep("groupV3d0", args); - return this; + return Wrap(this); } - public GraphTraversal Has(params object[] args) + public GraphTraversal Has(params object[] args) { Bytecode.AddStep("has", args); - return this; + return Wrap(this); } - public GraphTraversal HasId(params object[] args) + public GraphTraversal HasId(params object[] args) { Bytecode.AddStep("hasId", args); - return this; + return Wrap(this); } - public GraphTraversal HasKey(params object[] args) + public GraphTraversal HasKey(params object[] args) { Bytecode.AddStep("hasKey", args); - return this; + return Wrap(this); } - public GraphTraversal HasLabel(params object[] args) + public GraphTraversal HasLabel(params object[] args) { Bytecode.AddStep("hasLabel", args); - return this; + return Wrap(this); } - public GraphTraversal HasNot(params object[] args) + public GraphTraversal HasNot(params object[] args) { Bytecode.AddStep("hasNot", args); - return this; + return Wrap(this); } - public GraphTraversal HasValue(params object[] args) + public GraphTraversal HasValue(params object[] args) { Bytecode.AddStep("hasValue", args); - return this; + return Wrap(this); } - public GraphTraversal Id(params object[] args) + public GraphTraversal Id(params object[] args) { Bytecode.AddStep("id", args); - return this; + return Wrap(this); } - public GraphTraversal Identity(params object[] args) + public GraphTraversal Identity(params object[] args) { Bytecode.AddStep("identity", args); - return this; + return Wrap(this); } - public GraphTraversal In(params object[] args) + public GraphTraversal In(params object[] args) { Bytecode.AddStep("in", args); - return this; + return Wrap(this); } - public GraphTraversal InE(params object[] args) + public GraphTraversal InE(params object[] args) { Bytecode.AddStep("inE", args); - return this; + return Wrap(this); } - public GraphTraversal InV(params object[] args) + public GraphTraversal InV(params object[] args) { Bytecode.AddStep("inV", args); - return this; + return Wrap(this); } - public GraphTraversal Inject(params object[] args) + public GraphTraversal Inject(params object[] args) { Bytecode.AddStep("inject", args); - return this; + return Wrap(this); } - public GraphTraversal Is(params object[] args) + public GraphTraversal Is(params object[] args) { Bytecode.AddStep("is", args); - return this; + return Wrap(this); } - public GraphTraversal Key(params object[] args) + public GraphTraversal Key(params object[] args) { Bytecode.AddStep("key", args); - return this; + return Wrap(this); } - public GraphTraversal Label(params object[] args) + public GraphTraversal Label(params object[] args) { Bytecode.AddStep("label", args); - return this; + return Wrap(this); } - public GraphTraversal Limit(params object[] args) + public GraphTraversal Limit(params object[] args) { Bytecode.AddStep("limit", args); - return this; + return Wrap(this); } - public GraphTraversal Local(params object[] args) + public GraphTraversal Local(params object[] args) { Bytecode.AddStep("local", args); - return this; + return Wrap(this); } - public GraphTraversal Loops(params object[] args) + public GraphTraversal Loops(params object[] args) { Bytecode.AddStep("loops", args); - return this; + return Wrap(this); } - public GraphTraversal Map(params object[] args) + public GraphTraversal Map(params object[] args) { Bytecode.AddStep("map", args); - return this; + return Wrap(this); } - public GraphTraversal MapKeys(params object[] args) + public GraphTraversal MapKeys(params object[] args) { Bytecode.AddStep("mapKeys", args); - return this; + return Wrap(this); } - public GraphTraversal MapValues(params object[] args) + public GraphTraversal MapValues(params object[] args) { Bytecode.AddStep("mapValues", args); - return this; + return Wrap(this); } - public GraphTraversal Match(params object[] args) + public GraphTraversal> Match(params object[] args) { Bytecode.AddStep("match", args); - return this; + return Wrap>(this); } - public GraphTraversal Max(params object[] args) + public GraphTraversal Max(params object[] args) { Bytecode.AddStep("max", args); - return this; + return Wrap(this); } - public GraphTraversal Mean(params object[] args) + public GraphTraversal Mean(params object[] args) { Bytecode.AddStep("mean", args); - return this; + return Wrap(this); } - public GraphTraversal Min(params object[] args) + public GraphTraversal Min(params object[] args) { Bytecode.AddStep("min", args); - return this; + return Wrap(this); } - public GraphTraversal Not(params object[] args) + public GraphTraversal Not(params object[] args) { Bytecode.AddStep("not", args); - return this; + return Wrap(this); } - public GraphTraversal Option(params object[] args) + public GraphTraversal Option(params object[] args) { Bytecode.AddStep("option", args); - return this; + return Wrap(this); } - public GraphTraversal Optional(params object[] args) + public GraphTraversal Optional(params object[] args) { Bytecode.AddStep("optional", args); - return this; + return Wrap(this); } - public GraphTraversal Or(params object[] args) + public GraphTraversal Or(params object[] args) { Bytecode.AddStep("or", args); - return this; + return Wrap(this); } - public GraphTraversal Order(params object[] args) + public GraphTraversal Order(params object[] args) { Bytecode.AddStep("order", args); - return this; + return Wrap(this); } - public GraphTraversal OtherV(params object[] args) + public GraphTraversal OtherV(params object[] args) { Bytecode.AddStep("otherV", args); - return this; + return Wrap(this); } - public GraphTraversal Out(params object[] args) + public GraphTraversal Out(params object[] args) { Bytecode.AddStep("out", args); - return this; + return Wrap(this); } - public GraphTraversal OutE(params object[] args) + public GraphTraversal OutE(params object[] args) { Bytecode.AddStep("outE", args); - return this; + return Wrap(this); } - public GraphTraversal OutV(params object[] args) + public GraphTraversal OutV(params object[] args) { Bytecode.AddStep("outV", args); - return this; + return Wrap(this); } - public GraphTraversal PageRank(params object[] args) + public GraphTraversal PageRank(params object[] args) { Bytecode.AddStep("pageRank", args); - return this; + return Wrap(this); } - public GraphTraversal Path(params object[] args) + public GraphTraversal Path(params object[] args) { Bytecode.AddStep("path", args); - return this; + return Wrap(this); } - public GraphTraversal PeerPressure(params object[] args) + public GraphTraversal PeerPressure(params object[] args) { Bytecode.AddStep("peerPressure", args); - return this; + return Wrap(this); } - public GraphTraversal Profile(params object[] args) + public GraphTraversal Profile(params object[] args) { Bytecode.AddStep("profile", args); - return this; + return Wrap(this); } - public GraphTraversal Program(params object[] args) + public GraphTraversal Program(params object[] args) { Bytecode.AddStep("program", args); - return this; + return Wrap(this); } - public GraphTraversal Project(params object[] args) + public GraphTraversal> Project(params object[] args) { Bytecode.AddStep("project", args); - return this; + return Wrap>(this); } - public GraphTraversal Properties(params object[] args) + public GraphTraversal Properties(params object[] args) { Bytecode.AddStep("properties", args); - return this; + return Wrap(this); } - public GraphTraversal Property(params object[] args) + public GraphTraversal Property(params object[] args) { Bytecode.AddStep("property", args); - return this; + return Wrap(this); } - public GraphTraversal PropertyMap(params object[] args) + public GraphTraversal> PropertyMap(params object[] args) { Bytecode.AddStep("propertyMap", args); - return this; + return Wrap>(this); } - public GraphTraversal Range(params object[] args) + public GraphTraversal Range(params object[] args) { Bytecode.AddStep("range", args); - return this; + return Wrap(this); } - public GraphTraversal Repeat(params object[] args) + public GraphTraversal Repeat(params object[] args) { Bytecode.AddStep("repeat", args); - return this; + return Wrap(this); } - public GraphTraversal Sack(params object[] args) + public GraphTraversal Sack(params object[] args) { Bytecode.AddStep("sack", args); - return this; + return Wrap(this); } - public GraphTraversal Sample(params object[] args) + public GraphTraversal Sample(params object[] args) { Bytecode.AddStep("sample", args); - return this; + return Wrap(this); } - public GraphTraversal Select(params object[] args) + public GraphTraversal> Select(params object[] args) { Bytecode.AddStep("select", args); - return this; + return Wrap>(this); } - public GraphTraversal SideEffect(params object[] args) + public GraphTraversal SideEffect(params object[] args) { Bytecode.AddStep("sideEffect", args); - return this; + return Wrap(this); } - public GraphTraversal SimplePath(params object[] args) + public GraphTraversal SimplePath(params object[] args) { Bytecode.AddStep("simplePath", args); - return this; + return Wrap(this); } - public GraphTraversal Store(params object[] args) + public GraphTraversal Store(params object[] args) { Bytecode.AddStep("store", args); - return this; + return Wrap(this); } - public GraphTraversal Subgraph(params object[] args) + public GraphTraversal Subgraph(params object[] args) { Bytecode.AddStep("subgraph", args); - return this; + return Wrap(this); } - public GraphTraversal Sum(params object[] args) + public GraphTraversal Sum(params object[] args) { Bytecode.AddStep("sum", args); - return this; + return Wrap(this); } - public GraphTraversal Tail(params object[] args) + public GraphTraversal Tail(params object[] args) { Bytecode.AddStep("tail", args); - return this; + return Wrap(this); } - public GraphTraversal TimeLimit(params object[] args) + public GraphTraversal TimeLimit(params object[] args) { Bytecode.AddStep("timeLimit", args); - return this; + return Wrap(this); } - public GraphTraversal Times(params object[] args) + public GraphTraversal Times(params object[] args) { Bytecode.AddStep("times", args); - return this; + return Wrap(this); } - public GraphTraversal To(params object[] args) + public GraphTraversal To(params object[] args) { Bytecode.AddStep("to", args); - return this; + return Wrap(this); } - public GraphTraversal ToE(params object[] args) + public GraphTraversal ToE(params object[] args) { Bytecode.AddStep("toE", args); - return this; + return Wrap(this); } - public GraphTraversal ToV(params object[] args) + public GraphTraversal ToV(params object[] args) { Bytecode.AddStep("toV", args); - return this; + return Wrap(this); } - public GraphTraversal Tree(params object[] args) + public GraphTraversal Tree(params object[] args) { Bytecode.AddStep("tree", args); - return this; + return Wrap(this); } - public GraphTraversal Unfold(params object[] args) + public GraphTraversal Unfold(params object[] args) { Bytecode.AddStep("unfold", args); - return this; + return Wrap(this); } - public GraphTraversal Union(params object[] args) + public GraphTraversal Union(params object[] args) { Bytecode.AddStep("union", args); - return this; + return Wrap(this); } - public GraphTraversal Until(params object[] args) + public GraphTraversal Until(params object[] args) { Bytecode.AddStep("until", args); - return this; + return Wrap(this); } - public GraphTraversal Value(params object[] args) + public GraphTraversal Value(params object[] args) { Bytecode.AddStep("value", args); - return this; + return Wrap(this); } - public GraphTraversal ValueMap(params object[] args) + public GraphTraversal> ValueMap(params object[] args) { Bytecode.AddStep("valueMap", args); - return this; + return Wrap>(this); } - public GraphTraversal Values(params object[] args) + public GraphTraversal Values(params object[] args) { Bytecode.AddStep("values", args); - return this; + return Wrap(this); } - public GraphTraversal Where(params object[] args) + public GraphTraversal Where(params object[] args) { Bytecode.AddStep("where", args); - return this; + return Wrap(this); } - } + } } diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversalSource.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversalSource.cs index 638278185e6..07d98fb23a8 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversalSource.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversalSource.cs @@ -24,6 +24,7 @@ using System.Collections.Generic; using Gremlin.Net.Process.Remote; using Gremlin.Net.Process.Traversal.Strategy.Decoration; +using Gremlin.Net.Structure; namespace Gremlin.Net.Process.Traversal { @@ -111,32 +112,25 @@ public GraphTraversalSource WithComputer(string graphComputer = null, int? worke return WithStrategies(new VertexProgramStrategy(graphComputer, workers, persist, result, vertices, edges, configuration)); } - public GraphTraversal E(params object[] args) + public GraphTraversal E(params object[] args) { - var traversal = new GraphTraversal(TraversalStrategies, new Bytecode(Bytecode)); + var traversal = new GraphTraversal(TraversalStrategies, new Bytecode(Bytecode)); traversal.Bytecode.AddStep("E", args); return traversal; } - public GraphTraversal V(params object[] args) + public GraphTraversal V(params object[] args) { - var traversal = new GraphTraversal(TraversalStrategies, new Bytecode(Bytecode)); + var traversal = new GraphTraversal(TraversalStrategies, new Bytecode(Bytecode)); traversal.Bytecode.AddStep("V", args); return traversal; } - public GraphTraversal AddV(params object[] args) + public GraphTraversal AddV(params object[] args) { - var traversal = new GraphTraversal(TraversalStrategies, new Bytecode(Bytecode)); + var traversal = new GraphTraversal(TraversalStrategies, new Bytecode(Bytecode)); traversal.Bytecode.AddStep("addV", args); return traversal; } - - public GraphTraversal Inject(params object[] args) - { - var traversal = new GraphTraversal(TraversalStrategies, new Bytecode(Bytecode)); - traversal.Bytecode.AddStep("inject", args); - return traversal; - } - } + } } diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/ITraversal.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/ITraversal.cs index cb472b7c937..cb1c80e2272 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/ITraversal.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/ITraversal.cs @@ -29,9 +29,10 @@ namespace Gremlin.Net.Process.Traversal { /// - /// A traversal represents a directed walk over a graph. + /// Represents the basic information for a walk over a graph. /// - public interface ITraversal : IDisposable, IEnumerator + /// + public interface ITraversal { /// /// Gets the representation of this traversal. @@ -47,25 +48,31 @@ public interface ITraversal : IDisposable, IEnumerator /// Gets or sets the 's of this traversal that hold the results of the traversal. /// IEnumerable Traversers { get; set; } + } + /// + /// A traversal represents a directed walk over a graph. + /// + public interface ITraversal : ITraversal, IEnumerator + { /// /// Gets the next result from the traversal. /// /// The result. - object Next(); + E Next(); /// /// Gets the next n-number of results from the traversal. /// /// The number of results to get. /// The n-results. - IEnumerable Next(int amount); + IEnumerable Next(int amount); /// /// Iterates all instances in the traversal. /// /// The fully drained traversal. - ITraversal Iterate(); + ITraversal Iterate(); /// /// Gets the next . @@ -74,16 +81,16 @@ public interface ITraversal : IDisposable, IEnumerator Traverser NextTraverser(); /// - /// Puts all the results into a . + /// Puts all the results into a . /// /// The results in a list. - List ToList(); + IList ToList(); /// - /// Puts all the results into a . + /// Puts all the results into a . /// /// The results in a set. - HashSet ToSet(); + ISet ToSet(); /// /// Starts a promise to execute a function on the current traversal that will be completed in the future. @@ -91,6 +98,6 @@ public interface ITraversal : IDisposable, IEnumerator /// The return type of the . /// The function to execute on the current traversal. /// The result of the executed . - Task Promise(Func callback); + Task Promise(Func, TReturn> callback); } } \ No newline at end of file diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/ITraversalStrategy.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/ITraversalStrategy.cs index 991a807dbad..013d62ad503 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/ITraversalStrategy.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/ITraversalStrategy.cs @@ -35,12 +35,12 @@ public interface ITraversalStrategy /// Applies the strategy to the given . /// /// The the strategy should be applied to. - void Apply(ITraversal traversal); + void Apply(ITraversal traversal); /// /// Applies the strategy to the given asynchronously. /// /// The the strategy should be applied to. - Task ApplyAsync(ITraversal traversal); + Task ApplyAsync(ITraversal traversal); } } \ No newline at end of file diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/NamingConversions.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/NamingConversions.cs new file mode 100644 index 00000000000..6f5fec53e2f --- /dev/null +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/NamingConversions.cs @@ -0,0 +1,86 @@ +#region License + +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +#endregion + +using System.Collections.Generic; + +namespace Gremlin.Net.Process.Traversal +{ + internal static class NamingConversions + { + /// + /// Gets the Java name equivalent for a given enum value + /// + internal static string GetEnumJavaName(string typeName, string value) + { + var key = $"{typeName}.{value}"; + string javaName; + if (!CSharpToJavaEnums.TryGetValue(key, out javaName)) + { + throw new KeyNotFoundException($"Java name for {key} not found"); + } + return javaName; + } + + internal static readonly IDictionary CSharpToJavaEnums = new Dictionary + { + {"T.Value", "value"}, + {"Order.Decr", "decr"}, + {"Order.KeyDecr", "keyDecr"}, + {"T.Key", "key"}, + {"Column.Values", "values"}, + {"Order.KeyIncr", "keyIncr"}, + {"Operator.Or", "or"}, + {"Order.ValueIncr", "valueIncr"}, + {"Cardinality.List", "list"}, + {"Order.Incr", "incr"}, + {"Pop.All", "all"}, + {"Operator.SumLong", "sumLong"}, + {"Pop.First", "first"}, + {"T.Label", "label"}, + {"Cardinality.Set", "set"}, + {"Order.Shuffle", "shuffle"}, + {"Direction.In", "IN"}, + {"Direction.Both", "BOTH"}, + {"Scope.Local", "local"}, + {"Operator.Max", "max"}, + {"Direction.Out", "OUT"}, + {"Scope.Global", "global"}, + {"Pick.Any", "any"}, + {"Order.ValueDecr", "valueDecr"}, + {"Column.Keys", "keys"}, + {"Operator.AddAll", "addAll"}, + {"Operator.Mult", "mult"}, + {"Pick.None", "none"}, + {"Pop.Last", "last"}, + {"Operator.And", "and"}, + {"T.Id", "id"}, + {"Operator.Min", "min"}, + {"Barrier.NormSack", "normSack"}, + {"Operator.Minus", "minus"}, + {"Cardinality.Single", "single"}, + {"Operator.Assign", "assign"}, + {"Operator.Div", "div"}, + {"Operator.Sum", "sum"} + }; + } +} \ No newline at end of file diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Operator.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Operator.cs index 563f0917eda..17b44a42a91 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Operator.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Operator.cs @@ -25,16 +25,16 @@ namespace Gremlin.Net.Process.Traversal { public enum Operator { - addAll, - and, - assign, - div, - max, - min, - minus, - mult, - or, - sum, - sumLong + AddAll, + And, + Assign, + Div, + Max, + Min, + Minus, + Mult, + Or, + Sum, + SumLong } } diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Order.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Order.cs index bbd0eab692e..179182b46fe 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Order.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Order.cs @@ -25,12 +25,12 @@ namespace Gremlin.Net.Process.Traversal { public enum Order { - decr, - incr, - keyDecr, - keyIncr, - shuffle, - valueDecr, - valueIncr + Decr, + Incr, + KeyDecr, + KeyIncr, + Shuffle, + ValueDecr, + ValueIncr } } diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/P.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/P.cs index 0ecdccd605c..cf388bd005b 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/P.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/P.cs @@ -103,5 +103,5 @@ public static TraversalPredicate Without(params object[] args) var value = args.Length == 1 ? args[0] : args; return new TraversalPredicate("without", value); } - } + } } diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Pick.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Pick.cs index f16aa20b79b..624f66e82e6 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Pick.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Pick.cs @@ -25,7 +25,7 @@ namespace Gremlin.Net.Process.Traversal { public enum Pick { - any, - none + Any, + None } } diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Pop.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Pop.cs index e0cf62e7fcd..dcbe698e7e6 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Pop.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Pop.cs @@ -25,8 +25,8 @@ namespace Gremlin.Net.Process.Traversal { public enum Pop { - all, - first, - last + All, + First, + Last } } diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Scope.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Scope.cs index c4af316c42f..f27725e8a9d 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Scope.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Scope.cs @@ -25,7 +25,7 @@ namespace Gremlin.Net.Process.Traversal { public enum Scope { - global, - local + Global, + Local } } diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Strategy/AbstractTraversalStrategy.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Strategy/AbstractTraversalStrategy.cs index 8c9666c2dd1..e5d3dfe2bd4 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Strategy/AbstractTraversalStrategy.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/Strategy/AbstractTraversalStrategy.cs @@ -52,12 +52,12 @@ public bool Equals(AbstractTraversalStrategy other) } /// - public virtual void Apply(ITraversal traversal) + public virtual void Apply(ITraversal traversal) { } /// - public virtual Task ApplyAsync(ITraversal traversal) + public virtual Task ApplyAsync(ITraversal traversal) { return Task.CompletedTask; } diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/T.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/T.cs index 50c15d9f12a..76ca40f5a98 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/T.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/T.cs @@ -25,9 +25,9 @@ namespace Gremlin.Net.Process.Traversal { public enum T { - id, - key, - label, - value + Id, + Key, + Label, + Value } } diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/__.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/__.cs index e12037296b5..f2e6162921b 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/__.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/__.cs @@ -21,468 +21,471 @@ #endregion +using System.Collections.Generic; +using Gremlin.Net.Structure; + namespace Gremlin.Net.Process.Traversal { public static class __ { - public static GraphTraversal Start() + public static GraphTraversal Start() { - return new GraphTraversal(); + return new GraphTraversal(); } - public static GraphTraversal V(params object[] args) + public static GraphTraversal V(params object[] args) { - return new GraphTraversal().V(args); + return new GraphTraversal().V(args); } - public static GraphTraversal AddE(params object[] args) + public static GraphTraversal AddE(params object[] args) { - return new GraphTraversal().AddE(args); + return new GraphTraversal().AddE(args); } - public static GraphTraversal AddInE(params object[] args) + public static GraphTraversal AddInE(params object[] args) { - return new GraphTraversal().AddInE(args); + return new GraphTraversal().AddInE(args); } - public static GraphTraversal AddOutE(params object[] args) + public static GraphTraversal AddOutE(params object[] args) { - return new GraphTraversal().AddOutE(args); + return new GraphTraversal().AddOutE(args); } - public static GraphTraversal AddV(params object[] args) + public static GraphTraversal AddV(params object[] args) { - return new GraphTraversal().AddV(args); + return new GraphTraversal().AddV(args); } - public static GraphTraversal Aggregate(params object[] args) + public static GraphTraversal Aggregate(params object[] args) { - return new GraphTraversal().Aggregate(args); + return new GraphTraversal().Aggregate(args); } - public static GraphTraversal And(params object[] args) + public static GraphTraversal And(params object[] args) { - return new GraphTraversal().And(args); + return new GraphTraversal().And(args); } - public static GraphTraversal As(params object[] args) + public static GraphTraversal As(params object[] args) { - return new GraphTraversal().As(args); + return new GraphTraversal().As(args); } - public static GraphTraversal Barrier(params object[] args) + public static GraphTraversal Barrier(params object[] args) { - return new GraphTraversal().Barrier(args); + return new GraphTraversal().Barrier(args); } - public static GraphTraversal Both(params object[] args) + public static GraphTraversal Both(params object[] args) { - return new GraphTraversal().Both(args); + return new GraphTraversal().Both(args); } - public static GraphTraversal BothE(params object[] args) + public static GraphTraversal BothE(params object[] args) { - return new GraphTraversal().BothE(args); + return new GraphTraversal().BothE(args); } - public static GraphTraversal BothV(params object[] args) + public static GraphTraversal BothV(params object[] args) { - return new GraphTraversal().BothV(args); + return new GraphTraversal().BothV(args); } - public static GraphTraversal Branch(params object[] args) + public static GraphTraversal Branch(params object[] args) { - return new GraphTraversal().Branch(args); + return new GraphTraversal().Branch(args); } - public static GraphTraversal Cap(params object[] args) + public static GraphTraversal Cap(params object[] args) { - return new GraphTraversal().Cap(args); + return new GraphTraversal().Cap(args); } - public static GraphTraversal Choose(params object[] args) + public static GraphTraversal Choose(params object[] args) { - return new GraphTraversal().Choose(args); + return new GraphTraversal().Choose(args); } - public static GraphTraversal Coalesce(params object[] args) + public static GraphTraversal Coalesce(params object[] args) { - return new GraphTraversal().Coalesce(args); + return new GraphTraversal().Coalesce(args); } - public static GraphTraversal Coin(params object[] args) + public static GraphTraversal Coin(params object[] args) { - return new GraphTraversal().Coin(args); + return new GraphTraversal().Coin(args); } - public static GraphTraversal Constant(params object[] args) + public static GraphTraversal Constant(params object[] args) { - return new GraphTraversal().Constant(args); + return new GraphTraversal().Constant(args); } - public static GraphTraversal Count(params object[] args) + public static GraphTraversal Count(params object[] args) { - return new GraphTraversal().Count(args); + return new GraphTraversal().Count(args); } - public static GraphTraversal CyclicPath(params object[] args) + public static GraphTraversal CyclicPath(params object[] args) { - return new GraphTraversal().CyclicPath(args); + return new GraphTraversal().CyclicPath(args); } - public static GraphTraversal Dedup(params object[] args) + public static GraphTraversal Dedup(params object[] args) { - return new GraphTraversal().Dedup(args); + return new GraphTraversal().Dedup(args); } - public static GraphTraversal Drop(params object[] args) + public static GraphTraversal Drop(params object[] args) { - return new GraphTraversal().Drop(args); + return new GraphTraversal().Drop(args); } - public static GraphTraversal Emit(params object[] args) + public static GraphTraversal Emit(params object[] args) { - return new GraphTraversal().Emit(args); + return new GraphTraversal().Emit(args); } - public static GraphTraversal Filter(params object[] args) + public static GraphTraversal Filter(params object[] args) { - return new GraphTraversal().Filter(args); + return new GraphTraversal().Filter(args); } - public static GraphTraversal FlatMap(params object[] args) + public static GraphTraversal FlatMap(params object[] args) { - return new GraphTraversal().FlatMap(args); + return new GraphTraversal().FlatMap(args); } - public static GraphTraversal Fold(params object[] args) + public static GraphTraversal Fold(params object[] args) { - return new GraphTraversal().Fold(args); + return new GraphTraversal().Fold(args); } - public static GraphTraversal Group(params object[] args) + public static GraphTraversal Group(params object[] args) { - return new GraphTraversal().Group(args); + return new GraphTraversal().Group(args); } - public static GraphTraversal GroupCount(params object[] args) + public static GraphTraversal GroupCount(params object[] args) { - return new GraphTraversal().GroupCount(args); + return new GraphTraversal().GroupCount(args); } - public static GraphTraversal GroupV3d0(params object[] args) + public static GraphTraversal GroupV3d0(params object[] args) { - return new GraphTraversal().GroupV3d0(args); + return new GraphTraversal().GroupV3d0(args); } - public static GraphTraversal Has(params object[] args) + public static GraphTraversal Has(params object[] args) { - return new GraphTraversal().Has(args); + return new GraphTraversal().Has(args); } - public static GraphTraversal HasId(params object[] args) + public static GraphTraversal HasId(params object[] args) { - return new GraphTraversal().HasId(args); + return new GraphTraversal().HasId(args); } - public static GraphTraversal HasKey(params object[] args) + public static GraphTraversal HasKey(params object[] args) { - return new GraphTraversal().HasKey(args); + return new GraphTraversal().HasKey(args); } - public static GraphTraversal HasLabel(params object[] args) + public static GraphTraversal HasLabel(params object[] args) { - return new GraphTraversal().HasLabel(args); + return new GraphTraversal().HasLabel(args); } - public static GraphTraversal HasNot(params object[] args) + public static GraphTraversal HasNot(params object[] args) { - return new GraphTraversal().HasNot(args); + return new GraphTraversal().HasNot(args); } - public static GraphTraversal HasValue(params object[] args) + public static GraphTraversal HasValue(params object[] args) { - return new GraphTraversal().HasValue(args); + return new GraphTraversal().HasValue(args); } - public static GraphTraversal Id(params object[] args) + public static GraphTraversal Id(params object[] args) { - return new GraphTraversal().Id(args); + return new GraphTraversal().Id(args); } - public static GraphTraversal Identity(params object[] args) + public static GraphTraversal Identity(params object[] args) { - return new GraphTraversal().Identity(args); + return new GraphTraversal().Identity(args); } - public static GraphTraversal In(params object[] args) + public static GraphTraversal In(params object[] args) { - return new GraphTraversal().In(args); + return new GraphTraversal().In(args); } - public static GraphTraversal InE(params object[] args) + public static GraphTraversal InE(params object[] args) { - return new GraphTraversal().InE(args); + return new GraphTraversal().InE(args); } - public static GraphTraversal InV(params object[] args) + public static GraphTraversal InV(params object[] args) { - return new GraphTraversal().InV(args); + return new GraphTraversal().InV(args); } - public static GraphTraversal Inject(params object[] args) + public static GraphTraversal Inject(params object[] args) { - return new GraphTraversal().Inject(args); + return new GraphTraversal().Inject(args); } - public static GraphTraversal Is(params object[] args) + public static GraphTraversal Is(params object[] args) { - return new GraphTraversal().Is(args); + return new GraphTraversal().Is(args); } - public static GraphTraversal Key(params object[] args) + public static GraphTraversal Key(params object[] args) { - return new GraphTraversal().Key(args); + return new GraphTraversal().Key(args); } - public static GraphTraversal Label(params object[] args) + public static GraphTraversal Label(params object[] args) { - return new GraphTraversal().Label(args); + return new GraphTraversal().Label(args); } - public static GraphTraversal Limit(params object[] args) + public static GraphTraversal Limit(params object[] args) { - return new GraphTraversal().Limit(args); + return new GraphTraversal().Limit(args); } - public static GraphTraversal Local(params object[] args) + public static GraphTraversal Local(params object[] args) { - return new GraphTraversal().Local(args); + return new GraphTraversal().Local(args); } - public static GraphTraversal Loops(params object[] args) + public static GraphTraversal Loops(params object[] args) { - return new GraphTraversal().Loops(args); + return new GraphTraversal().Loops(args); } - public static GraphTraversal Map(params object[] args) + public static GraphTraversal Map(params object[] args) { - return new GraphTraversal().Map(args); + return new GraphTraversal().Map(args); } - public static GraphTraversal MapKeys(params object[] args) + public static GraphTraversal MapKeys(params object[] args) { - return new GraphTraversal().MapKeys(args); + return new GraphTraversal().MapKeys(args); } - public static GraphTraversal MapValues(params object[] args) + public static GraphTraversal MapValues(params object[] args) { - return new GraphTraversal().MapValues(args); + return new GraphTraversal().MapValues(args); } - public static GraphTraversal Match(params object[] args) + public static GraphTraversal> Match(params object[] args) { - return new GraphTraversal().Match(args); + return new GraphTraversal().Match(args); } - public static GraphTraversal Max(params object[] args) + public static GraphTraversal Max(params object[] args) { - return new GraphTraversal().Max(args); + return new GraphTraversal().Max(args); } - public static GraphTraversal Mean(params object[] args) + public static GraphTraversal Mean(params object[] args) { - return new GraphTraversal().Mean(args); + return new GraphTraversal().Mean(args); } - public static GraphTraversal Min(params object[] args) + public static GraphTraversal Min(params object[] args) { - return new GraphTraversal().Min(args); + return new GraphTraversal().Min(args); } - public static GraphTraversal Not(params object[] args) + public static GraphTraversal Not(params object[] args) { - return new GraphTraversal().Not(args); + return new GraphTraversal().Not(args); } - public static GraphTraversal Optional(params object[] args) + public static GraphTraversal Optional(params object[] args) { - return new GraphTraversal().Optional(args); + return new GraphTraversal().Optional(args); } - public static GraphTraversal Or(params object[] args) + public static GraphTraversal Or(params object[] args) { - return new GraphTraversal().Or(args); + return new GraphTraversal().Or(args); } - public static GraphTraversal Order(params object[] args) + public static GraphTraversal Order(params object[] args) { - return new GraphTraversal().Order(args); + return new GraphTraversal().Order(args); } - public static GraphTraversal OtherV(params object[] args) + public static GraphTraversal OtherV(params object[] args) { - return new GraphTraversal().OtherV(args); + return new GraphTraversal().OtherV(args); } - public static GraphTraversal Out(params object[] args) + public static GraphTraversal Out(params object[] args) { - return new GraphTraversal().Out(args); + return new GraphTraversal().Out(args); } - public static GraphTraversal OutE(params object[] args) + public static GraphTraversal OutE(params object[] args) { - return new GraphTraversal().OutE(args); + return new GraphTraversal().OutE(args); } - public static GraphTraversal OutV(params object[] args) + public static GraphTraversal OutV(params object[] args) { - return new GraphTraversal().OutV(args); + return new GraphTraversal().OutV(args); } - public static GraphTraversal Path(params object[] args) + public static GraphTraversal Path(params object[] args) { - return new GraphTraversal().Path(args); + return new GraphTraversal().Path(args); } - public static GraphTraversal Project(params object[] args) + public static GraphTraversal> Project(params object[] args) { - return new GraphTraversal().Project(args); + return new GraphTraversal().Project(args); } - public static GraphTraversal Properties(params object[] args) + public static GraphTraversal Properties(params object[] args) { - return new GraphTraversal().Properties(args); + return new GraphTraversal().Properties(args); } - public static GraphTraversal Property(params object[] args) + public static GraphTraversal Property(params object[] args) { - return new GraphTraversal().Property(args); + return new GraphTraversal().Property(args); } - public static GraphTraversal PropertyMap(params object[] args) + public static GraphTraversal> PropertyMap(params object[] args) { - return new GraphTraversal().PropertyMap(args); + return new GraphTraversal().PropertyMap(args); } - public static GraphTraversal Range(params object[] args) + public static GraphTraversal Range(params object[] args) { - return new GraphTraversal().Range(args); + return new GraphTraversal().Range(args); } - public static GraphTraversal Repeat(params object[] args) + public static GraphTraversal Repeat(params object[] args) { - return new GraphTraversal().Repeat(args); + return new GraphTraversal().Repeat(args); } - public static GraphTraversal Sack(params object[] args) + public static GraphTraversal Sack(params object[] args) { - return new GraphTraversal().Sack(args); + return new GraphTraversal().Sack(args); } - public static GraphTraversal Sample(params object[] args) + public static GraphTraversal Sample(params object[] args) { - return new GraphTraversal().Sample(args); + return new GraphTraversal().Sample(args); } - public static GraphTraversal Select(params object[] args) + public static GraphTraversal> Select(params object[] args) { - return new GraphTraversal().Select(args); + return new GraphTraversal().Select(args); } - public static GraphTraversal SideEffect(params object[] args) + public static GraphTraversal SideEffect(params object[] args) { - return new GraphTraversal().SideEffect(args); + return new GraphTraversal().SideEffect(args); } - public static GraphTraversal SimplePath(params object[] args) + public static GraphTraversal SimplePath(params object[] args) { - return new GraphTraversal().SimplePath(args); + return new GraphTraversal().SimplePath(args); } - public static GraphTraversal Store(params object[] args) + public static GraphTraversal Store(params object[] args) { - return new GraphTraversal().Store(args); + return new GraphTraversal().Store(args); } - public static GraphTraversal Subgraph(params object[] args) + public static GraphTraversal Subgraph(params object[] args) { - return new GraphTraversal().Subgraph(args); + return new GraphTraversal().Subgraph(args); } - public static GraphTraversal Sum(params object[] args) + public static GraphTraversal Sum(params object[] args) { - return new GraphTraversal().Sum(args); + return new GraphTraversal().Sum(args); } - public static GraphTraversal Tail(params object[] args) + public static GraphTraversal Tail(params object[] args) { - return new GraphTraversal().Tail(args); + return new GraphTraversal().Tail(args); } - public static GraphTraversal TimeLimit(params object[] args) + public static GraphTraversal TimeLimit(params object[] args) { - return new GraphTraversal().TimeLimit(args); + return new GraphTraversal().TimeLimit(args); } - public static GraphTraversal Times(params object[] args) + public static GraphTraversal Times(params object[] args) { - return new GraphTraversal().Times(args); + return new GraphTraversal().Times(args); } - public static GraphTraversal To(params object[] args) + public static GraphTraversal To(params object[] args) { - return new GraphTraversal().To(args); + return new GraphTraversal().To(args); } - public static GraphTraversal ToE(params object[] args) + public static GraphTraversal ToE(params object[] args) { - return new GraphTraversal().ToE(args); + return new GraphTraversal().ToE(args); } - public static GraphTraversal ToV(params object[] args) + public static GraphTraversal ToV(params object[] args) { - return new GraphTraversal().ToV(args); + return new GraphTraversal().ToV(args); } - public static GraphTraversal Tree(params object[] args) + public static GraphTraversal Tree(params object[] args) { - return new GraphTraversal().Tree(args); + return new GraphTraversal().Tree(args); } - public static GraphTraversal Unfold(params object[] args) + public static GraphTraversal Unfold(params object[] args) { - return new GraphTraversal().Unfold(args); + return new GraphTraversal().Unfold(args); } - public static GraphTraversal Union(params object[] args) + public static GraphTraversal Union(params object[] args) { - return new GraphTraversal().Union(args); + return new GraphTraversal().Union(args); } - public static GraphTraversal Until(params object[] args) + public static GraphTraversal Until(params object[] args) { - return new GraphTraversal().Until(args); + return new GraphTraversal().Until(args); } - public static GraphTraversal Value(params object[] args) + public static GraphTraversal Value(params object[] args) { - return new GraphTraversal().Value(args); + return new GraphTraversal().Value(args); } - public static GraphTraversal ValueMap(params object[] args) + public static GraphTraversal> ValueMap(params object[] args) { - return new GraphTraversal().ValueMap(args); + return new GraphTraversal().ValueMap(args); } - public static GraphTraversal Values(params object[] args) + public static GraphTraversal Values(params object[] args) { - return new GraphTraversal().Values(args); + return new GraphTraversal().Values(args); } - public static GraphTraversal Where(params object[] args) + public static GraphTraversal Where(params object[] args) { - return new GraphTraversal().Where(args); + return new GraphTraversal().Where(args); } - } + } } diff --git a/gremlin-dotnet/src/Gremlin.Net/Structure/IO/GraphSON/EnumSerializer.cs b/gremlin-dotnet/src/Gremlin.Net/Structure/IO/GraphSON/EnumSerializer.cs index 6ed3cd48239..b4ab8703835 100644 --- a/gremlin-dotnet/src/Gremlin.Net/Structure/IO/GraphSON/EnumSerializer.cs +++ b/gremlin-dotnet/src/Gremlin.Net/Structure/IO/GraphSON/EnumSerializer.cs @@ -22,6 +22,7 @@ #endregion using System.Collections.Generic; +using Gremlin.Net.Process.Traversal; namespace Gremlin.Net.Structure.IO.GraphSON { @@ -30,8 +31,8 @@ internal class EnumSerializer : IGraphSONSerializer public Dictionary Dictify(dynamic objectData, GraphSONWriter writer) { var enumName = objectData.GetType().Name; - var enumValue = objectData.ToString(); - return GraphSONUtil.ToTypedValue(enumName, enumValue); + var valueJavaName = NamingConversions.GetEnumJavaName(enumName, objectData.ToString()); + return GraphSONUtil.ToTypedValue(enumName, valueJavaName); } } } \ No newline at end of file diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Remote/RemoteStrategyTests.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Remote/RemoteStrategyTests.cs index de91152ba61..7b99371c225 100644 --- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Remote/RemoteStrategyTests.cs +++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Remote/RemoteStrategyTests.cs @@ -1,4 +1,4 @@ -#region License +#region License /* * Licensed to the Apache Software Foundation (ASF) under one @@ -66,7 +66,7 @@ public async Task ShouldSendBytecodeToGremlinServerAsynchronouslyForTraversalPro Assert.Equal(expectedResult, actualResult); } - private DefaultTraversal CreateTraversalWithRemoteStrategy(Bytecode bytecode) + private DefaultTraversal CreateTraversalWithRemoteStrategy(Bytecode bytecode) { var remoteStrategy = new RemoteStrategy(new DriverRemoteConnection(new GremlinClient(new GremlinServer(TestHost, TestPort)))); @@ -74,7 +74,7 @@ private DefaultTraversal CreateTraversalWithRemoteStrategy(Bytecode bytecode) } } - internal class TestTraversal : DefaultTraversal + internal class TestTraversal : DefaultTraversal { public TestTraversal(ITraversalStrategy traversalStrategy, Bytecode bytecode) { diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/BytecodeGeneration/StrategiesTests.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/BytecodeGeneration/StrategiesTests.cs index 418b0e22cc4..ba01526c9f1 100644 --- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/BytecodeGeneration/StrategiesTests.cs +++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/BytecodeGeneration/StrategiesTests.cs @@ -1,4 +1,4 @@ -#region License +#region License /* * Licensed to the Apache Software Foundation (ASF) under one @@ -161,8 +161,8 @@ public void TraversalWithStrategies_StrategyWithTraversalInConfig_IncludeTravers Assert.Equal(new SubgraphStrategy(), bytecode.SourceInstructions[0].Arguments[0]); SubgraphStrategy strategy = bytecode.SourceInstructions[0].Arguments[0]; Assert.Equal(1, strategy.Configuration.Count); - Assert.Equal(typeof(GraphTraversal), strategy.Configuration["vertices"].GetType()); - GraphTraversal traversal = strategy.Configuration["vertices"]; + Assert.Equal(typeof(GraphTraversal), strategy.Configuration["vertices"].GetType()); + ITraversal traversal = strategy.Configuration["vertices"]; Assert.Equal("has", traversal.Bytecode.StepInstructions[0].OperatorName); Assert.Equal(new List {"name", "marko"}, traversal.Bytecode.StepInstructions[0].Arguments); } diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/EnumTests.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/EnumTests.cs index 6d0f5299091..562aa6e5825 100644 --- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/EnumTests.cs +++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/EnumTests.cs @@ -39,9 +39,9 @@ public void ShouldUseOrderDecrInByStep() var connection = _connectionFactory.CreateRemoteConnection(); var g = graph.Traversal().WithRemote(connection); - var orderedAges = g.V().Values("age").Order().By(Order.decr).ToList(); + var orderedAges = g.V().Values("age").Order().By(Order.Decr).ToList(); - Assert.Equal(new List {35, 32, 29, 27}, orderedAges); + Assert.Equal(new List {35, 32, 29, 27}, orderedAges); } [Fact] @@ -51,7 +51,7 @@ public void ShouldUseTLabelInHasStep() var connection = _connectionFactory.CreateRemoteConnection(); var g = graph.Traversal().WithRemote(connection); - var personsCount = g.V().Has(T.label, "person").Count().Next(); + var personsCount = g.V().Has(T.Label, "person").Count().Next(); Assert.Equal((long) 4, personsCount); } diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/GraphTraversalSourceTests.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/GraphTraversalSourceTests.cs index 0e56c2e379d..d471af34577 100644 --- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/GraphTraversalSourceTests.cs +++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/GraphTraversalSourceTests.cs @@ -1,4 +1,4 @@ -#region License +#region License /* * Licensed to the Apache Software Foundation (ASF) under one @@ -43,7 +43,7 @@ public void ShouldUseSideEffectSpecifiedInWithSideEffect() .V(1) .Out("created") .In("created") - .Values("name") + .Values("name") .Where(P.Within("a")) .ToList(); diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/GraphTraversalTests.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/GraphTraversalTests.cs index ba999f3a913..51efa7fdf27 100644 --- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/GraphTraversalTests.cs +++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/GraphTraversalTests.cs @@ -98,13 +98,18 @@ public void g_V_RepeatXBothX_TimesX5X_NextX10X() [Fact] public void g_V_HasXname_markoX_ValueMap_Next() { + //Unable to cast object of type + //'System.Collections.Generic.Dictionary`2[System.String,System.Object]' to type + //'System.Collections.Generic.IDictionary`2[System.String,System.Collections.Generic.IList`1[System.Object]]'. + + var graph = new Graph(); var connection = _connectionFactory.CreateRemoteConnection(); var g = graph.Traversal().WithRemote(connection); - var receivedValueMap = g.V().Has("name", "marko").ValueMap().Next(); + var receivedValueMap = g.V().Has("name", "marko").ValueMap().Next(); - var expectedValueMap = new Dictionary + var expectedValueMap = new Dictionary { {"age", new List {29}}, {"name", new List {"marko"}} @@ -119,7 +124,7 @@ public void g_V_RepeatXOutX_TimesX2X_ValuesXNameX() var connection = _connectionFactory.CreateRemoteConnection(); var g = graph.Traversal().WithRemote(connection); - var t = g.V().Repeat(__.Out()).Times(2).Values("name"); + var t = g.V().Repeat(__.Out()).Times(2).Values("name"); var names = t.ToList(); Assert.Equal((long) 2, names.Count); @@ -135,7 +140,7 @@ public void ShortestPathTest() var g = graph.Traversal().WithRemote(connection); var shortestPath = - (Path) g.V(5).Repeat(__.Both().SimplePath()).Until(__.HasId(6)).Limit(1).Path().Next(); + (Path)g.V(5).Repeat(__.Both().SimplePath()).Until(__.HasId(6)).Limit(1).Path().Next(); Assert.Equal((long) 4, shortestPath.Count); Assert.Equal(new Vertex((long) 6), shortestPath[3]); diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/SideEffectTests.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/SideEffectTests.cs index c3629bcdc6f..f100e046062 100644 --- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/SideEffectTests.cs +++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/SideEffectTests.cs @@ -1,4 +1,4 @@ -#region License +#region License /* * Licensed to the Apache Software Foundation (ASF) under one @@ -123,7 +123,7 @@ public void ShouldReturnBothSideEffectForTraversalWithTwoSideEffects_() var connection = _connectionFactory.CreateRemoteConnection(); var g = graph.Traversal().WithRemote(connection); - var t = g.V().Out("created").GroupCount("m").By("name").Values("name").Aggregate("n").Iterate(); + var t = g.V().Out("created").GroupCount("m").By("name").Values("name").Aggregate("n").Iterate(); var keys = t.SideEffects.Keys().ToList(); Assert.Equal(2, keys.Count); diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/StrategiesTests.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/StrategiesTests.cs index 6c7d8b619f6..ba56de96a3b 100644 --- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/StrategiesTests.cs +++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Process/Traversal/DriverRemoteConnection/StrategiesTests.cs @@ -1,4 +1,4 @@ -#region License +#region License /* * Licensed to the Apache Software Foundation (ASF) under one @@ -119,7 +119,7 @@ public void g_E_Count_Next_WithEdgeLimitSubgraphStrategy() var g = graph.Traversal() .WithRemote(connection) - .WithStrategies(new SubgraphStrategy(edgeCriterion: __.Limit(0))); + .WithStrategies(new SubgraphStrategy(edgeCriterion: __.Limit(0))); var count = g.E().Count().Next(); @@ -151,7 +151,7 @@ public void g_V_ValuesXnameX_Next_WithVertexHasPropertySubgraphStrategy() .WithRemote(connection) .WithStrategies(new SubgraphStrategy(vertexCriterion: __.Has("name", "marko"))); - var name = g.V().Values("name").Next(); + var name = g.V().Values("name").Next(); Assert.Equal("marko", name); } diff --git a/gremlin-dotnet/test/Gremlin.Net.UnitTest/Process/Traversal/TestTraversal.cs b/gremlin-dotnet/test/Gremlin.Net.UnitTest/Process/Traversal/TestTraversal.cs index 4be682358ab..bf9b6d1d2d7 100644 --- a/gremlin-dotnet/test/Gremlin.Net.UnitTest/Process/Traversal/TestTraversal.cs +++ b/gremlin-dotnet/test/Gremlin.Net.UnitTest/Process/Traversal/TestTraversal.cs @@ -1,4 +1,4 @@ -#region License +#region License /* * Licensed to the Apache Software Foundation (ASF) under one @@ -27,7 +27,7 @@ namespace Gremlin.Net.UnitTest.Process.Traversal { - public class TestTraversal : DefaultTraversal + public class TestTraversal : DefaultTraversal { public TestTraversal(List traverserObjs) { diff --git a/gremlin-dotnet/test/Gremlin.Net.UnitTest/Process/Traversal/TestTraversalStrategy.cs b/gremlin-dotnet/test/Gremlin.Net.UnitTest/Process/Traversal/TestTraversalStrategy.cs index 111469c6837..ded419d751d 100644 --- a/gremlin-dotnet/test/Gremlin.Net.UnitTest/Process/Traversal/TestTraversalStrategy.cs +++ b/gremlin-dotnet/test/Gremlin.Net.UnitTest/Process/Traversal/TestTraversalStrategy.cs @@ -1,4 +1,4 @@ -#region License +#region License /* * Licensed to the Apache Software Foundation (ASF) under one @@ -36,12 +36,12 @@ public TestTraversalStrategy(IEnumerable traversersToAddOnApplication _traversers = traversersToAddOnApplication; } - public void Apply(ITraversal traversal) + public void Apply(ITraversal traversal) { traversal.Traversers = _traversers; } - public Task ApplyAsync(ITraversal traversal) + public Task ApplyAsync(ITraversal traversal) { traversal.Traversers = _traversers; return Task.CompletedTask; diff --git a/gremlin-dotnet/test/Gremlin.Net.UnitTest/Structure/IO/GraphSON/BytecodeGraphSONSerializerTests.cs b/gremlin-dotnet/test/Gremlin.Net.UnitTest/Structure/IO/GraphSON/BytecodeGraphSONSerializerTests.cs index e367124522c..8ed7a3d4657 100644 --- a/gremlin-dotnet/test/Gremlin.Net.UnitTest/Structure/IO/GraphSON/BytecodeGraphSONSerializerTests.cs +++ b/gremlin-dotnet/test/Gremlin.Net.UnitTest/Structure/IO/GraphSON/BytecodeGraphSONSerializerTests.cs @@ -1,4 +1,4 @@ -#region License +#region License /* * Licensed to the Apache Software Foundation (ASF) under one @@ -143,7 +143,7 @@ public void ShouldSerializeBytecodeWithBindings() } } - internal class TestTraversal : DefaultTraversal + internal class TestTraversal : DefaultTraversal { public TestTraversal(Bytecode bytecode) { diff --git a/gremlin-dotnet/test/Gremlin.Net.UnitTest/Structure/IO/GraphSON/GraphSONWriterTests.cs b/gremlin-dotnet/test/Gremlin.Net.UnitTest/Structure/IO/GraphSON/GraphSONWriterTests.cs index 49786d7766b..77af2558f05 100644 --- a/gremlin-dotnet/test/Gremlin.Net.UnitTest/Structure/IO/GraphSON/GraphSONWriterTests.cs +++ b/gremlin-dotnet/test/Gremlin.Net.UnitTest/Structure/IO/GraphSON/GraphSONWriterTests.cs @@ -189,9 +189,9 @@ public void ShouldSerializeEnum() { var writer = CreateStandardGraphSONWriter(); - var serializedEnum = writer.WriteObject(T.label); + var serializedEnum = writer.WriteObject(Direction.Both); - var expectedGraphSON = "{\"@type\":\"g:T\",\"@value\":\"label\"}"; + var expectedGraphSON = "{\"@type\":\"g:Direction\",\"@value\":\"BOTH\"}"; Assert.Equal(expectedGraphSON, serializedEnum); } @@ -312,11 +312,6 @@ public void ShouldSerializeVertexWithLabel() } } - internal enum T - { - label - } - internal class TestGraphSONSerializer : IGraphSONSerializer { public string TestNamespace { get; set; }