/*
* 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.click.eclipse.ui.editor;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import org.apache.click.eclipse.ClickUtils;
import org.eclipse.jdt.core.Flags;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.ITypeHierarchy;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.Signature;
/**
* Provides accessors which are easy to use for JDT class model.
* This class would be used by the code completion in the Velocity editor.
*
* @author Naoki Takezoe
* @see TemplateContentAssistProcessor
*/
public class TemplateObject {
private IType type;
private String primitiveType;
/**
* The constructor.
*
* @param type the <code>IType</code> object
*/
public TemplateObject(IType type){
this.type = type;
}
/**
* The constructor for primitive types.
*
* @param primitiveType the primitive type name
*/
public TemplateObject(String primitiveType){
this.primitiveType = primitiveType;
}
/**
* Returns the specified method.
* If this object doesn't have the specified method, returns <code>null</code>.
*
* @param name the method name
* @return the specified method or <code>null</code>
*/
public TemplateObjectMethod getMethod(String name){
if(this.type!=null){
TemplateObjectMethod[] methods = getMethods();
for(int i=0;i<methods.length;i++){
if(methods[i].getName().equals(name)){
return methods[i];
}
}
}
return null;
}
/**
* Returns the specified property.
* If this object doesn't have the specified property, returns <code>null</code>.
*
* @param name the property name
* @return the specified property or <code>null</code>
*/
public TemplateObjectProperty getProperty(String name){
if(this.type!=null){
TemplateObjectProperty[] properties = getProperties();
for(int i=0;i<properties.length;i++){
if(properties[i].getName().equals(name)){
return properties[i];
}
}
}
return null;
}
/**
* Returns available methods in this object.
*
* @return the array of methods
*/
public TemplateObjectMethod[] getMethods(){
if(this.type!=null){
try {
IMethod[] methods = getAllMethods(type);
List<TemplateObjectMethod> result = new ArrayList<TemplateObjectMethod>();
for(int i=0;i<methods.length;i++){
if(Flags.isPublic(methods[i].getFlags()) && !methods[i].isConstructor()){
result.add(new TemplateObjectMethod(methods[i]));
}
}
return result.toArray(new TemplateObjectMethod[result.size()]);
} catch (JavaModelException e) {
}
}
return new TemplateObjectMethod[0];
}
/**
* Returns available fields in this object.
*
* @return the array of properties
*/
public TemplateObjectProperty[] getProperties(){
if(this.type!=null){
try {
IMethod[] methods = getAllMethods(type);
List<TemplateObjectProperty> result = new ArrayList<TemplateObjectProperty>();
for(int i=0;i<methods.length;i++){
if(Flags.isPublic(methods[i].getFlags()) && methods[i].getParameterTypes().length==0){
String name = methods[i].getElementName();
if((name.startsWith("get") && name.length() > 3) ||
(name.startsWith("is") && name.length() > 2)){
result.add(new TemplateObjectProperty(methods[i]));
}
}
}
return result.toArray(new TemplateObjectProperty[result.size()]);
} catch (JavaModelException e) {
}
}
return new TemplateObjectProperty[0];
}
/**
* Returns available methods and fields in this object.
*
* @return the array of both methods and properties
*/
public TemplateObjectElement[] getChildren(){
List<TemplateObjectElement> result = new ArrayList<TemplateObjectElement>();
if(this.type!=null){
TemplateObjectMethod[] methods = getMethods();
TemplateObjectProperty[] properties = getProperties();
for(int i=0;i<methods.length;i++){
result.add(methods[i]);
}
for(int i=0;i<properties.length;i++){
result.add(properties[i]);
}
Collections.sort(result, new Comparator<TemplateObjectElement>(){
public int compare(TemplateObjectElement arg0, TemplateObjectElement arg1) {
return arg0.toString().compareTo(arg1.toString());
}
});
}
return (TemplateObjectElement[])result.toArray(new TemplateObjectElement[result.size()]);
}
/**
* Tests whether this object is the primitive type.
*
* @return <code>true</code> if this is the primitive type;
* <code>false</code> otherwise
*/
public boolean isPrimitive(){
return this.type == null;
}
/**
* Returns the <code>IType</code> instance of this object.
*
* @return the <code>IType</code> instance.
* If this object is the primitive type, returns null.
*/
public IType getType(){
return this.type;
}
/**
* Returns the type name of this object.
*
* @return the full qualified class name or the primitive type name
*/
public String getTypeName(){
if(this.type!=null){
return this.type.getFullyQualifiedName();
} else {
return this.primitiveType;
}
}
///////////////////////////////////////////////////////////////////////////////////////
//
// Inner Classes
//
///////////////////////////////////////////////////////////////////////////////////////
/**
* The <code>TemplateObjectElement</code> implementation which expresses
* the proprty of <code>TemplateObject</code>
*/
public static class TemplateObjectProperty implements TemplateObjectElement {
private IMethod method;
public TemplateObjectProperty(IMethod method){
this.method = method;
}
public String getName(){
String name = this.method.getElementName();
if(name.startsWith("get")){
name = name.substring(3);
} else if(name.startsWith("is")){
name = name.substring(2);
}
return name.substring(0, 1).toLowerCase() + name.substring(1);
}
public String getDisplayName(){
StringBuffer sb = new StringBuffer();
sb.append(getName());
sb.append(" ");
try {
sb.append(getSimpleName(Signature.toString(this.method.getReturnType())));
} catch(Exception ex){
}
sb.append(" - ");
sb.append(this.method.getDeclaringType().getElementName());
return sb.toString();
}
/**
* Returns the <code>TemplateObject</code> by the property type.
*/
public TemplateObject toTemplateObject(){
try {
String className = ClickUtils.removeTypeParameter(Signature.toString(this.method.getReturnType()));
if(ClickUtils.isPrimitive(className)){
return null;
}
className = ClickUtils.resolveClassName(method.getDeclaringType(), className);
IJavaProject javaProject = method.getDeclaringType().getJavaProject();
IType type = javaProject.findType(className);
if(type!=null && type.exists()){
return new TemplateObject(type);
}
} catch(Exception ex){
}
return null;
}
public String toString(){
return getDisplayName();
}
}
/**
* The <code>TemplateObjectElement</code> implementation which expresses
* the method of <code>TemplateObject</code>
*/
public static class TemplateObjectMethod implements TemplateObjectElement {
private IMethod method;
public TemplateObjectMethod(IMethod method){
this.method = method;
}
public String getName(){
return this.method.getElementName();
}
// public int getArgumentCount(){
// return this.method.getParameterTypes().length;
// }
public String getDisplayName(){
StringBuffer sb = new StringBuffer();
sb.append(getName());
sb.append("(");
String[] types = this.method.getParameterTypes();
String[] names = null;
try {
names = this.method.getParameterNames();
} catch(Exception ex){
names = new String[types.length];
for(int i=0;i<names.length;i++){
names[i] = "arg" + i;
}
}
for(int i=0;i<types.length;i++){
if(i != 0){
sb.append(", ");
}
sb.append(getSimpleName(Signature.toString(types[i])));
sb.append(" ");
sb.append(names[i]);
}
sb.append(") ");
try {
sb.append(getSimpleName(Signature.toString(method.getReturnType())));
} catch(Exception ex){
}
sb.append(" - ");
sb.append(method.getDeclaringType().getElementName());
return sb.toString();
}
/**
* Returns the <code>TemplateObject</code> by the return type of the method.
*/
public TemplateObject toTemplateObject(){
// TODO This implementation is same to TemplateObjectProperty.
try {
String className = ClickUtils.removeTypeParameter(Signature.toString(this.method.getReturnType()));
if(ClickUtils.isPrimitive(className)){
return null;
}
className = ClickUtils.resolveClassName(method.getDeclaringType(), className);
IJavaProject javaProject = method.getDeclaringType().getJavaProject();
IType type = javaProject.findType(className);
if(type!=null && type.exists()){
return new TemplateObject(type);
}
} catch(Exception ex){
}
return null;
}
public String toString(){
return getDisplayName();
}
}
/**
* The interface of <code>TemplateObject</code> elements,
* expresses methods and properties.
*/
public static interface TemplateObjectElement {
/**
* Returns the element name.
*
* @return the element name
*/
public String getName();
/**
* Returns the display string.
*
* @return the display string which might contain type names or parameters
*/
public String getDisplayName();
/**
* Converts this object to the <code>TemplateObject</code>.
* <p>
* For example, if the instance corresponds a method,
* this method would return the <code>TemplateObject</code> of
* the method return type.
*
* @return the <code>TemplateObject</code> instance or <code>null</code>
*/
public TemplateObject toTemplateObject();
}
///////////////////////////////////////////////////////////////////////////////////////
//
// Utility methods
//
///////////////////////////////////////////////////////////////////////////////////////
/**
* Get the simple classname from the full qualified classname.
*
* @param name the full qualified classname
* @return the simple classname
*/
private static String getSimpleName(String name){
String simpleName = ClickUtils.removeTypeParameter(name);
if(simpleName.indexOf('.')>=0){
simpleName = simpleName.substring(simpleName.lastIndexOf('.') + 1);
}
return simpleName;
}
/**
* Returns all public methods of the given type.
*
* @param type the <code>IType</code> instance
* @return all methods of the given type, not contains main method and constructor
* @throws JavaModelException
*/
private static IMethod[] getAllMethods(IType type) throws JavaModelException {
ArrayList<IMethod> list = new ArrayList<IMethod>();
IMethod[] methods = type.getMethods();
for(int i=0;i<methods.length;i++){
if(!methods[i].isConstructor() && !methods[i].isMainMethod() && Flags.isPublic(methods[i].getFlags())){
list.add(methods[i]);
}
}
// search super class
ITypeHierarchy hierarchy = type.newSupertypeHierarchy(null);
extractMethods(hierarchy.getAllSuperclasses(type), list);
extractMethods(hierarchy.getSuperInterfaces(type), list);
if(type.isInterface()){
extractMethods(new IType[]{
type.getJavaProject().findType("java.lang.Object")}, list);
}
return (IMethod[])list.toArray(new IMethod[list.size()]);
}
private static void extractMethods(IType[] types, List<IMethod> methods) throws JavaModelException {
for(int i=0;i<types.length;i++){
IMethod[] superMethods = types[i].getMethods();
for(int j=0;j<superMethods.length;j++){
boolean flag = true;
if(!superMethods[j].isConstructor() && !superMethods[j].isMainMethod() && Flags.isPublic(superMethods[j].getFlags())){
for(int k=0;k<methods.size();k++){
IMethod method = (IMethod)methods.get(k);
if(equalsMethods(method, superMethods[j])){
flag = false;
break;
}
}
if(flag){
methods.add(superMethods[j]);
}
}
}
}
}
/**
* Tests whether given methods are same.
*
* @param method1 the <code>IMethod</code>
* @param method2 the <code>IMethod</code>
* @return <code>true</code> if given methods are same: <code>false</code> otherwise
*/
private static boolean equalsMethods(IMethod method1, IMethod method2){
if(method1.getElementName().equals(method2.getElementName())){
String[] params1 = method1.getParameterTypes();
String[] params2 = method2.getParameterTypes();
if(params1.length==params2.length){
for(int i=0;i<params1.length;i++){
if(!params1[i].equals(params2[i])){
return false;
}
}
return true;
}
}
return false;
}
}