/*******************************************************************************
* Copyright (c) 2004, 2005 Sybase, 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:
* Sybase, Inc. - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.jsf.facesconfig.ui.util;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.jdt.core.Flags;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IPackageDeclaration;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.ITypeHierarchy;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.Signature;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jst.jsf.common.ui.IFileFolderConstants;
import org.eclipse.jst.jsf.common.ui.internal.utils.JavaModelUtil;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.PartInitException;
/**
* This utility class defines typical operations on java class, such as check
* public constructor, and check type is primitive or not, etc.
*
* @author Jane Cantz, Xiao-guang Zhang
*/
public class JavaClassUtils {
/**
* Determines if a string contains any illegal characters
*
* @param text -
* the string to test
* @return boolean - true if an illegal character is found, otherwise false
*/
public static boolean hasIllegalCharacters(String text) {
if (text.length() == 0
|| !Character.isJavaIdentifierStart(text.charAt(0))) {
return true;
}
for (int i = 1; i < text.length(); i++) {
if (!Character.isJavaIdentifierPart(text.charAt(i))) {
return true;
}
}
return false;
}
/**
* Test for constructor.
* <p>
* This test determines if the class has any constructors
* </p>
*
* @param methods -
* the IMethod array to examine
* @return boolean - true, if method has no constructors
*/
public static boolean hasNoConstructor(IMethod[] methods) {
for (int m = 0; m < methods.length; m++) {
try {
if (methods[m].isConstructor()) {
return false;
}
} catch (JavaModelException e) {
// suppress: this is possible; fall through
}
}
return true;
}
/**
* check whether the method is public or not.
*
* @param method
* @return true if method is public
*/
public static boolean isPublicMethod(IMethod method) {
int accessFlags = 0;
try {
accessFlags = method.getFlags();
} catch (JavaModelException e) {
return false;
}
boolean isPublic = Flags.isPublic(accessFlags);
if ((!Flags.isPrivate(accessFlags))
&& (!Flags.isProtected(accessFlags))
&& (!Flags.isPublic(accessFlags))) {
// No specific modifier was set, so assume to be public
isPublic = true;
}
if (!isPublic) {
return false;
}
return true;
}
/**
* Test for constructor.
* <p>
* This test has the following conditions:
* </p>
* <ul>
* <li>method takes 0 arguments and the method name is the class name:
* <ul>
* <li>takes 0 arguments</li>
* <li>the method name is the class name</li>
* <li>the method returns void</code></li>
* </ul>
* </li>
* </ul>
*
* @param methods -
* the IMethod array to examine
* @return boolean - true, if method is a constructor
*/
public static boolean hasPublicConstructor(IMethod[] methods) {
for (int m = 0; m < methods.length; m++) {
try {
if (methods[m].isConstructor() && isPublicMethod(methods[m])) {
// Constructor must have the following 0 arguments
String[] params = methods[m].getParameterTypes();
if (params.length == 0) {
// And must return a void
String rtn = methods[m].getReturnType();
if (rtn.equals(Signature.SIG_VOID)) {
return true;
}
break;
}
}
} catch (JavaModelException e) {
// Nothing to do.
}
}
return false;
}
/**
* Determines if a datatype is primitive type or part of java.lang or
* java.util package. If not, it is considered to be a bean reference
*
* @param classType -
* the parent class compilation unit
* @param signatureName -
* the datatype of the property
* @return boolean - true, if the datatype is primitive or part of java.lang
* or java.util package
*/
public static boolean isPrimitiveType(IType classType, String signatureName) {
while (signatureName.startsWith("[")) { //$NON-NLS-1$
signatureName = signatureName.substring(1);
}
int kind = Signature.getTypeSignatureKind(signatureName);
if (kind == Signature.BASE_TYPE_SIGNATURE
|| signatureName.equals(Signature.SIG_VOID)) {
// These are true primitive types
return true;
}
String qualifiedName = getQualifiedTypeNameInTypeHierarchy(classType,
signatureName);
if ((qualifiedName.startsWith("java.lang")) || (qualifiedName.startsWith("java.util"))) //$NON-NLS-1$ //$NON-NLS-2$
{
return true;
}
return false;
}
/**
* get the type from the input class name
*
* @param project
* @param className
* @return - can be null.
*/
public static IType getType(IProject project, String className) {
if (project == null) {
return null;
}
IType cunit = null;
if (className.length() > 0) {
IJavaProject jProject = JavaCore.create(project);
try {
cunit = jProject.findType(className);
} catch (JavaModelException e) {
// suppress: fall-through and return null
}
}
return cunit;
}
/**
* open the type in the editor.
*
* @param type
* @return true if the type could opened in an editor
*/
public static boolean openType(IType type) {
if (type == null || !type.exists()) {
return false;
}
try {
IEditorPart editorPart = JavaUI.openInEditor(type
.getPrimaryElement());
if (editorPart != null) {
JavaUI.revealInEditor(editorPart, type.getPrimaryElement());
return true;
}
} catch (PartInitException e) {
// ignore this error.
} catch (JavaModelException e) {
// ignore this error.
}
return false;
}
/**
* get package name from java source file
*
* @param javaFile
* @return - can be null.
*/
public static String getPackageName(IFile javaFile) {
if (javaFile == null) {
return null;
}
String ext = "." + javaFile.getFileExtension(); //$NON-NLS-1$
// See if the file is a java file
if (!ext.equalsIgnoreCase(IFileFolderConstants.EXT_JAVA)) {
return null;
}
String packagename = new String();
ICompilationUnit cunit = JavaCore.createCompilationUnitFrom(javaFile);
try {
IPackageDeclaration[] packages = cunit.getPackageDeclarations();
if (packages.length == 0) {
packagename = new String();
} else {
packagename = packages[0].getElementName();
}
} catch (JavaModelException jme) {
// suppress: fall-through and return an empty string?? TODO:?
}
return packagename;
}
/**
* copy the array to the list.
*
* @param methodList
* @param methods
*/
private static void copyToMethodList(List methodList, IMethod[] methods) {
if (methods != null && methods.length > 0) {
for (int i = 0; i < methods.length; i++) {
if (!isDuplicateMethod(methodList, methods[i])) {
methodList.add(methods[i]);
}
}
}
}
/**
* check whether this method is duplicated or not in the existing method
* list.
*
* @param methodList
* @param method
* @return
*/
private static boolean isDuplicateMethod(List methodList, IMethod method) {
if (method == null || !method.exists()) {
return false;
}
String[] paramTypes = method.getParameterTypes();
String methodName = method.getElementName();
for (Iterator iter = methodList.iterator(); iter.hasNext();) {
IMethod existedMethod = (IMethod) iter.next();
if (isSameMethodSignature(methodName, paramTypes, existedMethod)) {
return true;
}
}
return false;
}
/**
* Tests if a method equals to the given signature. Parameter types are only
* compared by the simple name, no resolving for the fully qualified type
* name is done. Constructors are only compared by parameters, not the name.
*
* @param name
* Name of the method
* @param paramTypes
* The type signatures of the parameters e.g.
* <code>{"QString;","I"}</code>
* @param curr
* @return Returns <code>true</code> if the method has the given name and
* parameter types and constructor state.
*/
public static boolean isSameMethodSignature(String name,
String[] paramTypes, IMethod curr) {
if (name.equals(curr.getElementName())) {
String[] currParamTypes = curr.getParameterTypes();
if (paramTypes.length == currParamTypes.length) {
for (int i = 0; i < paramTypes.length; i++) {
String t1 = Signature.getSimpleName(Signature
.toString(paramTypes[i]));
String t2 = Signature.getSimpleName(Signature
.toString(currParamTypes[i]));
if (!t1.equals(t2)) {
return false;
}
}
return true;
}
}
return false;
}
/**
* get methods for the class Type including its super class
*
* @param classType
* @return - can be null
* @throws JavaModelException
*/
public static IMethod[] getMethods(IType classType)
throws JavaModelException {
if (classType == null) {
return null;
}
List methodList = new ArrayList();
IMethod[] methods = classType.getMethods();
copyToMethodList(methodList, methods);
ITypeHierarchy typeHierarchy = classType.newSupertypeHierarchy(null);
if (typeHierarchy != null) {
IType[] superTypes = typeHierarchy.getAllSuperclasses(classType);
if (superTypes != null && superTypes.length > 0) {
for (int i = 0; i < superTypes.length; i++) {
if (!superTypes[i].getFullyQualifiedName().equals(
"java.lang.Object")) { //$NON-NLS-1$
methods = superTypes[i].getMethods();
copyToMethodList(methodList, methods);
}
}
}
}
if (methodList != null && methodList.size() > 0) {
IMethod[] validMethods = (IMethod[]) methodList
.toArray(new IMethod[methodList.size()]);
Arrays.sort(validMethods, new Comparator() {
public int compare(Object o1, Object o2) {
String name1 = ((IMethod) o1).getElementName();
String name2 = ((IMethod) o2).getElementName();
return name1.compareTo(name2);
}
});
return validMethods;
}
return null;
}
/**
* resolve and get the qualified name for the incomplete typename
*
* @param classType
* @param signatureName
* @return - at least equal to Signature.toString(signatureName).
*/
public static String getQualifiedTypeNameInTypeHierarchy(IType classType,
String signatureName) {
int arrayNum = 0;
while (signatureName.startsWith("[")) { //$NON-NLS-1$
arrayNum++;
signatureName = signatureName.substring(1);
}
String qualifiedTypeName = Signature.toString(signatureName);
int kind = Signature.getTypeSignatureKind(signatureName);
if (kind == Signature.BASE_TYPE_SIGNATURE
|| signatureName.equals(Signature.SIG_VOID)) {
// Add back array identifiers
while (arrayNum > 0) {
qualifiedTypeName = qualifiedTypeName + "[]"; //$NON-NLS-1$
arrayNum--;
}
return qualifiedTypeName;
}
String typeName = Signature.toString(signatureName);
String foundName = getQualifiedTypeName(classType, typeName);
// if found in current type
if (foundName != null) {
qualifiedTypeName = foundName;
} else // else found in the type hierachy.
{
ITypeHierarchy typeHierarchy = null;
try {
typeHierarchy = classType.newSupertypeHierarchy(null);
} catch (JavaModelException e) {
// Nothing to do.
}
if (typeHierarchy != null) {
IType[] superTypes = typeHierarchy.getAllSupertypes(classType);
if (superTypes != null && superTypes.length > 0) {
for (int i = 0; i < superTypes.length; i++) {
if (!superTypes[i].getFullyQualifiedName().equals(
"java.lang.Object")) { //$NON-NLS-1$
foundName = getQualifiedTypeName(superTypes[i],
typeName);
if (foundName != null) {
qualifiedTypeName = foundName;
break;
}
}
}
}
}
}
// Add back array identifiers
while (arrayNum > 0) {
qualifiedTypeName = qualifiedTypeName + "[]"; //$NON-NLS-1$
arrayNum--;
}
return qualifiedTypeName;
}
/**
* resolve and get the qualified name for the incomplete typename
*
* @param classType
* @param typeName
* @return can be null.
*/
public static String getQualifiedTypeName(IType classType, String typeName) {
String qualifiedTypeName = null;
try {
String[][] resolvedNames = classType.resolveType(typeName);
if (resolvedNames != null && resolvedNames.length > 0) {
qualifiedTypeName = JavaModelUtil.concatenateName(
resolvedNames[0][0], resolvedNames[0][1]);
}
} catch (JavaModelException e1) {
// Nothing to do.
}
return qualifiedTypeName;
}
/**
* check whether subclass is sub class of supperclass
*
* @param jProject
* @param subClass -
* fully qualified name of sub class
* @param superClass -
* fully qualified name of super class
*
* @return true if subClass is a sub of superClass
*/
public static boolean isSubClassOf(IJavaProject jProject, String subClass,
String superClass) {
if (jProject == null || subClass == null || superClass == null) {
return false;
}
try {
IType subClassType = jProject.findType(subClass);
if (subClassType != null) {
ITypeHierarchy typeHierarchy = null;
try {
typeHierarchy = subClassType.newSupertypeHierarchy(null);
} catch (JavaModelException e) {
// Nothing to do.
}
IType[] superTypes = typeHierarchy
.getAllSupertypes(subClassType);
if (superTypes != null && superTypes.length > 0) {
for (int i = 0; i < superTypes.length; i++) {
if (superTypes[i].getFullyQualifiedName().equals(
superClass)) {
return true;
}
}
}
}
} catch (JavaModelException e) {
// Nothing to do.
}
return false;
}
}