Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.tinkerpop.gremlin.jsr223; import org.apache.commons.configuration.Configuration; import org.apache.commons.configuration.MapConfiguration; import org.apache.tinkerpop.gremlin.process.traversal.Bytecode; import org.apache.tinkerpop.gremlin.process.traversal.Translator; import org.apache.tinkerpop.gremlin.process.traversal.Traversal; import org.apache.tinkerpop.gremlin.process.traversal.TraversalSource; import org.apache.tinkerpop.gremlin.process.traversal.strategy.TraversalStrategyProxy; import org.apache.tinkerpop.gremlin.structure.util.StringFactory; import java.lang.reflect.Array; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Parameter; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; /** * @author Marko A. Rodriguez (http://markorodriguez.com) */ public final class JavaTranslator<S extends TraversalSource, T extends Traversal.Admin<?, ?>> implements Translator.StepTranslator<S, T> { private final S traversalSource; private final Class anonymousTraversal; private static final Map<Class<?>, Map<String, List<Method>>> GLOBAL_METHOD_CACHE = new ConcurrentHashMap<>(); private JavaTranslator(final S traversalSource) { this.traversalSource = traversalSource; this.anonymousTraversal = traversalSource.getAnonymousTraversalClass().orElse(null); } public static <S extends TraversalSource, T extends Traversal.Admin<?, ?>> JavaTranslator<S, T> of( final S traversalSource) { return new JavaTranslator<>(traversalSource); } @Override public S getTraversalSource() { return this.traversalSource; } @Override public T translate(final Bytecode bytecode) { TraversalSource dynamicSource = this.traversalSource; Traversal.Admin<?, ?> traversal = null; for (final Bytecode.Instruction instruction : bytecode.getSourceInstructions()) { dynamicSource = (TraversalSource) invokeMethod(dynamicSource, TraversalSource.class, instruction.getOperator(), instruction.getArguments()); } boolean spawned = false; for (final Bytecode.Instruction instruction : bytecode.getStepInstructions()) { if (!spawned) { traversal = (Traversal.Admin) invokeMethod(dynamicSource, Traversal.class, instruction.getOperator(), instruction.getArguments()); spawned = true; } else invokeMethod(traversal, Traversal.class, instruction.getOperator(), instruction.getArguments()); } return (T) traversal; } @Override public String getTargetLanguage() { return "gremlin-java"; } @Override public String toString() { return StringFactory.translatorString(this); } //// private Object translateObject(final Object object) { if (object instanceof Bytecode.Binding) return translateObject(((Bytecode.Binding) object).value()); else if (object instanceof Bytecode) { try { final Traversal.Admin<?, ?> traversal = (Traversal.Admin) this.anonymousTraversal.getMethod("start") .invoke(null); for (final Bytecode.Instruction instruction : ((Bytecode) object).getStepInstructions()) { invokeMethod(traversal, Traversal.class, instruction.getOperator(), instruction.getArguments()); } return traversal; } catch (final Throwable e) { throw new IllegalStateException(e.getMessage()); } } else if (object instanceof TraversalStrategyProxy) { final Map<String, Object> map = new HashMap<>(); final Configuration configuration = ((TraversalStrategyProxy) object).getConfiguration(); configuration.getKeys() .forEachRemaining(key -> map.put(key, translateObject(configuration.getProperty(key)))); try { return map.isEmpty() ? ((TraversalStrategyProxy) object).getStrategyClass().getMethod("instance").invoke(null) : ((TraversalStrategyProxy) object).getStrategyClass() .getMethod("create", Configuration.class).invoke(null, new MapConfiguration(map)); } catch (final NoSuchMethodException | InvocationTargetException | IllegalAccessException e) { throw new IllegalStateException(e.getMessage(), e); } } else if (object instanceof Map) { final Map<Object, Object> map = new LinkedHashMap<>(((Map) object).size()); for (final Map.Entry<?, ?> entry : ((Map<?, ?>) object).entrySet()) { map.put(translateObject(entry.getKey()), translateObject(entry.getValue())); } return map; } else if (object instanceof List) { final List<Object> list = new ArrayList<>(((List) object).size()); for (final Object o : (List) object) { list.add(translateObject(o)); } return list; } else if (object instanceof Set) { final Set<Object> set = new HashSet<>(((Set) object).size()); for (final Object o : (Set) object) { set.add(translateObject(o)); } return set; } else return object; } private Object invokeMethod(final Object delegate, final Class returnType, final String methodName, final Object... arguments) { // populate method cache for fast access to methods in subsequent calls final Map<String, List<Method>> methodCache = GLOBAL_METHOD_CACHE.getOrDefault(delegate.getClass(), new HashMap<>()); if (methodCache.isEmpty()) buildMethodCache(delegate, methodCache); // create a copy of the argument array so as not to mutate the original bytecode final Object[] argumentsCopy = new Object[arguments.length]; for (int i = 0; i < arguments.length; i++) { argumentsCopy[i] = translateObject(arguments[i]); } try { for (final Method method : methodCache.get(methodName)) { if (returnType.isAssignableFrom(method.getReturnType())) { if (method.getParameterCount() == argumentsCopy.length || (method.getParameterCount() > 0 && method.getParameters()[method.getParameters().length - 1].isVarArgs())) { final Parameter[] parameters = method.getParameters(); final Object[] newArguments = new Object[parameters.length]; boolean found = true; for (int i = 0; i < parameters.length; i++) { if (parameters[i].isVarArgs()) { final Class<?> parameterClass = parameters[i].getType().getComponentType(); if (argumentsCopy.length > i && !parameterClass.isAssignableFrom(argumentsCopy[i].getClass())) { found = false; break; } Object[] varArgs = (Object[]) Array.newInstance(parameterClass, argumentsCopy.length - i); int counter = 0; for (int j = i; j < argumentsCopy.length; j++) { varArgs[counter++] = argumentsCopy[j]; } newArguments[i] = varArgs; break; } else { if (i < argumentsCopy.length && (parameters[i].getType() .isAssignableFrom(argumentsCopy[i].getClass()) || (parameters[i].getType().isPrimitive() && (Number.class.isAssignableFrom(argumentsCopy[i].getClass()) || argumentsCopy[i].getClass().equals(Boolean.class) || argumentsCopy[i].getClass().equals(Byte.class) || argumentsCopy[i].getClass().equals(Character.class))))) { newArguments[i] = argumentsCopy[i]; } else { found = false; break; } } } if (found) { return 0 == newArguments.length ? method.invoke(delegate) : method.invoke(delegate, newArguments); } } } } } catch (final Throwable e) { throw new IllegalStateException( e.getMessage() + ":" + methodName + "(" + Arrays.toString(argumentsCopy) + ")", e); } throw new IllegalStateException("Could not locate method: " + delegate.getClass().getSimpleName() + "." + methodName + "(" + Arrays.toString(argumentsCopy) + ")"); } private synchronized static void buildMethodCache(final Object delegate, final Map<String, List<Method>> methodCache) { if (methodCache.isEmpty()) { for (final Method method : delegate.getClass().getMethods()) { if (!(method.getName().equals("addV") && method.getParameterCount() == 1 && method.getParameters()[0].getType().equals(Object[].class))) { // hack cause its hard to tell Object[] vs. String :| List<Method> list = methodCache.get(method.getName()); if (null == list) { list = new ArrayList<>(); methodCache.put(method.getName(), list); } list.add(method); } } GLOBAL_METHOD_CACHE.put(delegate.getClass(), methodCache); } } }