Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (C) 2010-2012 eBusiness Information, Excilys Group 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 com.googlecode.androidannotations.helper;
 
 import static com.sun.codemodel.JExpr.cast;
 import static com.sun.codemodel.JMod.PUBLIC;
 import static com.sun.codemodel.JMod.STATIC;
 import static javax.lang.model.element.ElementKind.CONSTRUCTOR;
 
 import java.util.List;
 
 
 
 public class APTCodeModelHelper {
 
 	public JClass typeMirrorToJClass(TypeMirror typeEBeanHolder holder) {
 
 		if (type instanceof DeclaredType) {
 			DeclaredType declaredType = (DeclaredTypetype;
 
 			String declaredTypeName = declaredType.asElement().toString();
 
 			JClass declaredClass = holder.refClass(declaredTypeName);
 
 			List<? extends TypeMirrortypeArguments = declaredType.getTypeArguments();
 
 			List<JClasstypeArgumentJClasses = new ArrayList<JClass>();
 			for (TypeMirror typeArgument : typeArguments) {
 				typeArgumentJClasses.add(typeMirrorToJClass(typeArgumentholder));
 			}
 			if (typeArgumentJClasses.size() > 0) {
 				declaredClass = declaredClass.narrow(typeArgumentJClasses);
 			}
 
 			return declaredClass;
 		} else if (type instanceof ArrayType) {
 			ArrayType arrayType = (ArrayTypetype;
 
 			JClass refClass = typeMirrorToJClass(arrayType.getComponentType(), holder);
 
 			return refClass.array();
 		} else {
 			return holder.refClass(type.toString());
 		}
 	}
 
 	public static class Parameter {
 		public final String name;
 		public final JClass jClass;
 
 		public Parameter(String nameJClass jClass) {
 			this. = name;
 			this. = jClass;
 		}
 	}
 
 	public JMethod overrideAnnotatedMethod(ExecutableElement executableElementEBeanHolder holder) {
 
 		String methodName = executableElement.getSimpleName().toString();
 
 		JClass returnType = typeMirrorToJClass(executableElement.getReturnType(), holder);
		List<Parameterparameters = new ArrayList<Parameter>();
		for (VariableElement parameter : executableElement.getParameters()) {
			String parameterName = parameter.getSimpleName().toString();
			JClass parameterClass = typeMirrorToJClass(parameter.asType(), holder);
			parameters.add(new Parameter(parameterNameparameterClass));
		}
		JMethod existingMethod = findAlreadyGeneratedMethod(holder.eBeanmethodNameparameters);
		if (existingMethod != null) {
			return existingMethod;
		}
		JMethod method = holder.eBean.method(.returnTypemethodName);
		method.annotate(Override.class);
		List<JVarmethodParameters = new ArrayList<JVar>();
		for (VariableElement parameter : executableElement.getParameters()) {
			String parameterName = parameter.getSimpleName().toString();
			JClass parameterClass = typeMirrorToJClass(parameter.asType(), holder);
			JVar param = method.param(.parameterClassparameterName);
			methodParameters.add(param);
		}
		for (TypeMirror superThrownType : executableElement.getThrownTypes()) {
			JClass thrownType = typeMirrorToJClass(superThrownTypeholder);
			method._throws(thrownType);
		}
		callSuperMethod(methodholdermethod.body());
		return method;
	}
	private JMethod findAlreadyGeneratedMethod(JDefinedClass definedClassString methodNameList<Parameterparameters) {
		method: for (JMethod method : definedClass.methods()) {
			if (method.name().equals(methodName) && method.params().size() == parameters.size()) {
				int i = 0;
				for (JVar param : method.params()) {
					String searchedParamType = parameters.get(i)..name();
					if (!param.type().name().equals(searchedParamType)) {
						continue method;
					}
					i++;
				}
				return method;
			}
		}
		return null;
	}
	public void callSuperMethod(JMethod superMethodEBeanHolder holderJBlock callBlock) {
		JExpression activitySuper = holder.eBean.staticRef("super");
		JInvocation superCall = JExpr.invoke(activitySupersuperMethod);
		for (JVar param : superMethod.params()) {
			superCall.arg(param);
		}
		JType returnType = superMethod.type();
		if (returnType.fullName().equals("void")) {
			callBlock.add(superCall);
else {
			callBlock._return(superCall);
		}
	}
	public JBlock removeBody(JMethod method) {
		JBlock body = method.body();
		try {
			Field bodyField = JMethod.class.getDeclaredField("body");
			bodyField.setAccessible(true);
			bodyField.set(methodnull);
catch (Exception e) {
			throw new RuntimeException(e);
		}
		JBlock clonedBody = new JBlock(falsefalse);
		for (Object statement : body.getContents()) {
			clonedBody.add((JStatementstatement);
		}
		return clonedBody;
	}
		try {
			Field nameField = JFieldRef.class.getDeclaredField("name");
			nameField.setAccessible(true);
			String name = (StringnameField.get(idRef);
			if (name != null) {
				return name;
			}
			Field varField = JFieldRef.class.getDeclaredField("var");
			varField.setAccessible(true);
			JVar var = (JVarvarField.get(idRef);
			if (var != null) {
				return var.name();
			}
catch (Exception e) {
			throw new RuntimeException(e);
		}
		throw new IllegalStateException("Unable to extract target name from JFieldRef");
	}
		JCodeModel codeModel = holder.codeModel();
		Classes classes = holder.classes();
		JDefinedClass anonymousRunnableClass;
		JBlock previousMethodBody = removeBody(delegatedMethod);
		anonymousRunnableClass = codeModel.anonymousClass(Runnable.class);
		JMethod runMethod = anonymousRunnableClass.method(.codeModel.VOID"run");
		runMethod.annotate(Override.class);
		JBlock runMethodBody = runMethod.body();
		JTryBlock runTry = runMethodBody._try();
		runTry.body().add(previousMethodBody);
		JCatchBlock runCatch = runTry._catch(classes.RUNTIME_EXCEPTION);
		JVar exceptionParam = runCatch.param("e");
		JInvocation errorInvoke = classes.LOG.staticInvoke("e");
		errorInvoke.arg(holder.eBean.name());
		errorInvoke.arg("A runtime exception was thrown while executing code in a runnable");
		errorInvoke.arg(exceptionParam);
		runCatch.body().add(errorInvoke);
		return anonymousRunnableClass;
	}
	public JVar castContextToActivity(EBeanHolder holderJBlock ifActivityBody) {
		JClass activityClass = holder.classes().;
		return ifActivityBody.decl(activityClass"activity"cast(activityClassholder.contextRef));
	}
	public JBlock ifContextInstanceOfActivity(EBeanHolder holderJBlock methodBody) {
		return methodBody._if(holder.contextRef._instanceof(holder.classes().))._then();
	}
	public void copyConstructorsAndAddStaticEViewBuilders(Element elementJCodeModel codeModelJClass eBeanClassEBeanHolder holderJMethod setContentViewMethod) {
		for (Element e : element.getEnclosedElements()) {
			if (e.getKind() == ) {
				constructors.add((ExecutableElemente);
			}
		}
		for (ExecutableElement userConstructor : constructors) {
			JMethod copyConstructor = holder.eBean.constructor();
			JMethod staticHelper = holder.eBean.method( | eBeanClass"build");
			JBlock body = copyConstructor.body();
			JInvocation superCall = body.invoke("super");
			JInvocation newInvocation = JExpr._new(holder.eBean);
			for (VariableElement param : userConstructor.getParameters()) {
				String paramName = param.getSimpleName().toString();
				String paramType = param.asType().toString();
				copyConstructor.param(holder.refClass(paramType), paramName);
				staticHelper.param(holder.refClass(paramType), paramName);
				superCall.arg(JExpr.ref(paramName));
				newInvocation.arg(JExpr.ref(paramName));
			}
			JVar newCall = staticHelper.body().decl(holder.eBean"instance"newInvocation);
			staticHelper.body().invoke(newCall"onFinishInflate");
			staticHelper.body()._return(newCall);
			body.invoke(holder.init);
		}
	}
	public JVar findParameterByName(JMethod methodString name) {
		for (JVar parameter : method.params()) {
			if (parameter.name().equals(name)) {
				return parameter;
			}
		}
		return null;
	}
New to GrepCode? Check out our FAQ X