AsyncAnnotationProcessor.java

/*******************************************************************************
* Copyright (c) 2010 Composent, Inc. and others. All rights reserved. This
* program and the accompanying materials are made available under the terms of
* the Eclipse Public License v1.0 which accompanies this distribution, and is
* available at http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
*   Composent, Inc. - initial API and implementation
******************************************************************************/
package org.eclipse.ecf.internal.remoteservice.apt.java6;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Filer;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.ArrayType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.tools.JavaFileObject;

import org.eclipse.ecf.internal.remoteservice.apt.java6.JavaFormatter.AccessSpecifier;
import org.eclipse.ecf.remoteservice.AsyncService;
import org.eclipse.ecf.remoteservice.IAsyncRemoteServiceProxy;

@SupportedAnnotationTypes({ "org.eclipse.ecf.remoteservice.AsyncService" }) 
public class AsyncAnnotationProcessor extends AbstractProcessor {

	private static final String FUTURE_PACKAGE_IMPORT = org.eclipse.equinox.concurrent.future.IFuture.class.getName();
	private static final String REMOTESERVICE_PACKAGE_IMPORT = org.eclipse.ecf.remoteservice.IAsyncCallback.class.getName();

	public AsyncAnnotationProcessor() {
		super();
	}
	
	public boolean process(Set<? extends TypeElement> annotations,
			RoundEnvironment roundEnv) {
		ProcessingEnvironment env = super.processingEnv;
		Filer filer = env.getFiler();
		Set<TypeElement> annotatedDecls = (Set<TypeElement>) roundEnv.getElementsAnnotatedWith(AsyncService.class);
		for(Iterator<TypeElement> i = annotatedDecls.iterator(); i.hasNext(); ) {
			writeAsyncType(filer,i.next());
		}
		return true;
	}

	private void writeAsyncType(Filer filer, TypeElement te) {
		String qualifiedAsyncName = te.getQualifiedName().toString()+IAsyncRemoteServiceProxy.ASYNC_INTERFACE_SUFFIX;
		String simpleAsyncName = te.getSimpleName().toString()+IAsyncRemoteServiceProxy.ASYNC_INTERFACE_SUFFIX;
		int lastDot = qualifiedAsyncName.lastIndexOf(".");
		String packageAsyncName = null;
		if (lastDot > 0) {
			packageAsyncName = qualifiedAsyncName.substring(0,lastDot);
		}
		JavaFileObject javaFile = null;
		try {
			javaFile = filer.createSourceFile(qualifiedAsyncName, (Element[]) null);
			Writer writer = javaFile.openWriter();
			PrintWriter pw = new PrintWriter(writer);
			JavaFormatter formatter = new JavaFormatter(pw);
			if (packageAsyncName != null) {
				formatter.printPackage(packageAsyncName);
				pw.println();
			}
			formatter.printImport(FUTURE_PACKAGE_IMPORT);
			formatter.printImport(REMOTESERVICE_PACKAGE_IMPORT);
			pw.println();
			formatter.printText("@SuppressWarnings(\"restriction\")");
			formatter.openInterface(AccessSpecifier.PUBLIC, simpleAsyncName, new String[] { IAsyncRemoteServiceProxy.class.getName() });
			pw.println();
			writeAsyncMethods(filer, te, (List<ExecutableElement>) te.getEnclosedElements(), formatter);
			pw.println();
			formatter.closeElement();
			writer.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private void writeAsyncMethods(Filer filer, TypeElement te,
			List<ExecutableElement> list, JavaFormatter formatter) {
		for(Iterator<ExecutableElement> i = list.iterator(); i.hasNext(); ) {
		   ExecutableElement elem = i.next();
		   writeAsyncMethodCallback(elem, formatter);
		   writeAsyncMethodFuture(elem, formatter);
		}
	}

	private void writeAsyncMethodCallback(ExecutableElement methodDecl,
			JavaFormatter formatter) {
		   String resultType = getResultTypeForExecutableElement(methodDecl);
		   List<VariableElement> methodParams = (List<VariableElement>) methodDecl.getParameters();
		   List ptypes = new ArrayList();
		   List ps = new ArrayList();
		   for(Iterator<VariableElement> i=methodParams.iterator(); i.hasNext(); ) {
			   VariableElement m = i.next();
			   TypeMirror tm = m.asType();
			   ptypes.add(tm.toString());
			   ps.add(m.getSimpleName().toString());
		   }
		   final String asyncCallbackClassname = "IAsyncCallback";
		   if (resultType == null) {
			   ptypes.add(asyncCallbackClassname+"<Void>");
		   } else {
			   ptypes.add(asyncCallbackClassname+"<"+resultType+">");
		   }
		   ps.add("callback");
		   formatter.openMethod(false, AccessSpecifier.PUBLIC, null, methodDecl.getSimpleName()+IAsyncRemoteServiceProxy.ASYNC_METHOD_SUFFIX, (String[]) ptypes.toArray(new String[] {}), (String[]) ps.toArray(new String[] {}), false);
	}

	private String getBoxedTypeNameForTypeMirror(TypeMirror resultType) {
		if (resultType == null) return null;
		if (resultType instanceof ArrayType) {
			ArrayType at = (ArrayType) resultType;
			String boxedType = getBoxedTypeNameForTypeMirror(at.getComponentType());
			if (boxedType == null) return null;
			return boxedType+"[]";
		}
		TypeKind type = resultType.getKind();
		if (type == null) return null;
        if (type.equals(TypeKind.BOOLEAN)) {
			return "Boolean";
		} else if (type.equals(TypeKind.BYTE)) {
			return "Byte";
		} else if (type.equals(TypeKind.CHAR)) {
			return "Character";
		} else if (type.equals(TypeKind.DOUBLE)) {
			return "Double";
		} else if (type.equals(TypeKind.FLOAT)) {
			return "Float";
		} else if (type.equals(TypeKind.INT)) {
			return "Integer";
		} else if (type.equals(TypeKind.LONG)) {
			return "Long";
		} else if (type.equals(TypeKind.SHORT)) {
			return "Short";
		} else if (type.equals(TypeKind.VOID)) {
			return "Void";
		} else if (type.equals(TypeKind.DECLARED)) {
			return resultType.toString();
		}
        return null;
	}
	private String getResultTypeForExecutableElement(ExecutableElement methodDecl) {
		if (methodDecl == null) return null;
		TypeMirror returnType = methodDecl.getReturnType();
		if (returnType == null) return null;
		return getBoxedTypeNameForTypeMirror(returnType);
	}
	
	private void writeAsyncMethodFuture(ExecutableElement methodDecl,
			JavaFormatter formatter) {
		   List<VariableElement> methodParams = (List<VariableElement>) methodDecl.getParameters();
		   List ptypes = new ArrayList();
		   List ps = new ArrayList();
		   for(Iterator<VariableElement> i=methodParams.iterator(); i.hasNext(); ) {
			   VariableElement m = i.next();
			   TypeMirror tm = m.asType();
			   ptypes.add(tm.toString());
			   ps.add(m.getSimpleName().toString());
		   }
		   formatter.printText("@SuppressWarnings(\"rawtypes\")");
		   formatter.openMethod(false, AccessSpecifier.PUBLIC, "IFuture", methodDecl.getSimpleName()+IAsyncRemoteServiceProxy.ASYNC_METHOD_SUFFIX, (String[]) ptypes.toArray(new String[] {}), (String[]) ps.toArray(new String[] {}), false);
	}

}