java.lang.reflect.Method Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2011-2014 Fernando Petrola
 *
 * Licensed 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 java.lang.reflect;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.List;

import com.dragome.commons.compiler.annotations.CompilerType;
import com.dragome.commons.compiler.annotations.DragomeCompilerSettings;
import com.dragome.commons.compiler.annotations.MethodAlias;
import com.dragome.commons.javascript.ScriptHelper;
import com.dragome.helpers.DragomeEntityManager;
import com.dragome.services.ServiceInvocation;
import com.dragome.services.WebServiceLocator;
import com.dragome.web.annotations.ClientSideMethod;
import com.dragome.web.debugging.JavascriptReference;
import com.dragome.web.dispatcher.JavaRefId;
import com.dragome.web.enhancers.jsdelegate.JsCast;

import sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl;

@DragomeCompilerSettings(CompilerType.Standard)
public final class Method extends Executable
{
	protected String signature;
	protected Class cls;
	protected boolean accessible;
	protected Class[] parametersTypes;
	protected Class returnType;
	private int modifiers;

	public Method(Class newCls, String theSignature, int modifiers)
	{
		signature= theSignature;
		cls= newCls;
		this.modifiers= modifiers;
	}

	public String getName()
	{
		String name= signature.substring(1, signature.lastIndexOf("$"));

		int parametersStart= name.indexOf("___");
		if (parametersStart != -1)
			return name.substring(0, parametersStart);
		else
			return name;
	}

	public Class[] getParameterTypes()
	{
		String signatureWithNoReturnType= signature.substring(0, signature.lastIndexOf("$"));
		String[] parameters= signatureWithNoReturnType.replaceAll("____", "__").replaceAll("___", "__").split("__");
		List> result= new ArrayList>();

		if (parameters.length > 1)
		{
			for (int i= 1; i < parameters.length; i++)
			{
				String typeName= parameters[i];
				if (typeName.trim().length() > 0 && !typeName.contains("$"))
				{
					//			typeName= boxTypes(typeName);

					Class parameterType= Object.class;
					try
					{
						parameterType= Class.forName(fixArrayClassName(typeName));
					}
					catch (Exception e)
					{
					}

					result.add(parameterType);
				}
			}
			return result.toArray(new Class[0]);
		}
		else
			return new Class[0];
	}

	public static String boxTypes(String typeName)
	{
		if ("boolean".equals(typeName))
			return "java.lang.Boolean";
		else if ("int".equals(typeName))
			return "java.lang.Integer";
		else if ("long".equals(typeName))
			return "java.lang.Long";
		else if ("short".equals(typeName))
			return "java.lang.Short";
		else if ("float".equals(typeName))
			return "java.lang.Float";
		else if ("double".equals(typeName))
			return "java.lang.Double";
		else if ("byte".equals(typeName))
			return "java.lang.Byte";
		else if ("char".equals(typeName))
			return "java.lang.Character";

		return typeName;
	}

	public Object invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException
	{
		boxArguments(getParameterTypes(), args);

		Object result= null;
		if (obj == null)
		{
			ScriptHelper.put("relatedClass", cls, this);
			obj= ScriptHelper.eval("relatedClass.$$$nativeClass", this);
		}

		ScriptHelper.put("obj", obj, this);
		ScriptHelper.put("args", args, this);
		ScriptHelper.put("sig", this.signature, this);

		Object instanceMethod= ScriptHelper.eval("obj[sig]", this);

		if (instanceMethod == null)
			result= ScriptHelper.eval("obj.clazz.constructor[sig](args)", this);
		else
			result= ScriptHelper.eval("obj[sig].apply(obj, args)", this);

		result= adaptResult(result, getReturnType());
		return result;
	}

	@MethodAlias(local_alias= "apply")
	public Object javaCall(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException
	{
		WebServiceLocator webServiceLocator= WebServiceLocator.getInstance();
		boolean executeAtServer= webServiceLocator.isRemoteDebugging() && getAnnotation(ClientSideMethod.class) == null;

		Class[] parameterTypes= getParameterTypes();
		Object[] typedArguments= new Object[parameterTypes.length];

		for (int j= 0; j < args.length; j++)
		{
			Object object= args[j];
			Object typedArgument= JsCast.castTo(object, parameterTypes[j]);
			typedArguments[j]= typedArgument;
			//			ScriptHelper.put("a", object, this);
			//			ScriptHelper.eval("console.log(a)", this);
		}

		if (executeAtServer)
		{
			ScriptHelper.put("obj", obj, this);
			String javaRefIdString= (String) ScriptHelper.eval("obj.javaRefId", this);

			JavaRefId javaRefId= new JavaRefId(javaRefIdString);

			List