Java tutorial
/******************************************************************************* * Copyright (c) 2006 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.common.ui.internal.utils; import java.util.Arrays; import java.util.HashSet; import java.util.Set; import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IResource; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.Path; import org.eclipse.jdt.core.ClasspathContainerInitializer; import org.eclipse.jdt.core.Flags; import org.eclipse.jdt.core.IClasspathContainer; import org.eclipse.jdt.core.IClasspathEntry; import org.eclipse.jdt.core.ICompilationUnit; import org.eclipse.jdt.core.IField; import org.eclipse.jdt.core.IImportDeclaration; import org.eclipse.jdt.core.IJavaElement; import org.eclipse.jdt.core.IJavaProject; import org.eclipse.jdt.core.IMember; import org.eclipse.jdt.core.IMethod; import org.eclipse.jdt.core.IPackageFragment; import org.eclipse.jdt.core.IPackageFragmentRoot; 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.core.compiler.CharOperation; /** * Original code is from JDT Utility methods for the Java Model. */ public final class JavaModelUtil { /** * Finds a type by its qualified type name (dot separated). * * @param jproject * The java project to search in * @param fullyQualifiedName * The fully qualified name (type name with enclosing type names * and package (all separated by dots)) * @return The type found, or null if not existing * @throws JavaModelException */ public static IType findType(IJavaProject jproject, String fullyQualifiedName) throws JavaModelException { // workaround for bug 22883 IType type = jproject.findType(fullyQualifiedName); if (type != null) { return type; } IPackageFragmentRoot[] roots = jproject.getPackageFragmentRoots(); for (int i = 0; i < roots.length; i++) { IPackageFragmentRoot root = roots[i]; type = findType(root, fullyQualifiedName); if (type != null && type.exists()) { return type; } } return null; } /** * Returns <code>true</code> if the given package fragment root is * referenced. This means it is own by a different project but is referenced * by the root's parent. Returns <code>false</code> if the given root * doesn't have an underlying resource. * @param root * @return true if root is referenced */ public static boolean isReferenced(IPackageFragmentRoot root) { IResource resource = root.getResource(); if (resource != null) { IProject jarProject = resource.getProject(); IProject container = root.getJavaProject().getProject(); return !container.equals(jarProject); } return false; } private static IType findType(IPackageFragmentRoot root, String fullyQualifiedName) throws JavaModelException { IJavaElement[] children = root.getChildren(); for (int i = 0; i < children.length; i++) { IJavaElement element = children[i]; if (element.getElementType() == IJavaElement.PACKAGE_FRAGMENT) { IPackageFragment pack = (IPackageFragment) element; if (!fullyQualifiedName.startsWith(pack.getElementName())) { continue; } IType type = findType(pack, fullyQualifiedName); if (type != null && type.exists()) { return type; } } } return null; } private static IType findType(IPackageFragment pack, String fullyQualifiedName) throws JavaModelException { ICompilationUnit[] cus = pack.getCompilationUnits(); for (int i = 0; i < cus.length; i++) { ICompilationUnit unit = cus[i]; IType type = findType(unit, fullyQualifiedName); if (type != null && type.exists()) { return type; } } return null; } private static IType findType(ICompilationUnit cu, String fullyQualifiedName) throws JavaModelException { IType[] types = cu.getAllTypes(); for (int i = 0; i < types.length; i++) { IType type = types[i]; if (getFullyQualifiedName(type).equals(fullyQualifiedName)) { return type; } } return null; } /** * Finds a type by package and type name. * * @param jproject * the java project to search in * @param pack * The package name * @param typeQualifiedName * the type qualified name (type name with enclosing type names * (separated by dots)) * @return the type found, or null if not existing * @throws JavaModelException * @deprecated Use IJavaProject.findType(String, String) instead */ public static IType findType(IJavaProject jproject, String pack, String typeQualifiedName) throws JavaModelException { return jproject.findType(pack, typeQualifiedName); } /** * Finds a type container by container name. The returned element will be of * type <code>IType</code> or a <code>IPackageFragment</code>. * <code>null</code> is returned if the type container could not be found. * * @param jproject * The Java project defining the context to search * @param typeContainerName * A dot separarted name of the type container * @return the java element * @throws JavaModelException * @see #getTypeContainerName(IType) */ public static IJavaElement findTypeContainer(IJavaProject jproject, String typeContainerName) throws JavaModelException { // try to find it as type IJavaElement result = jproject.findType(typeContainerName); if (result == null) { // find it as package IPath path = new Path(typeContainerName.replace('.', '/')); result = jproject.findElement(path); if (!(result instanceof IPackageFragment)) { result = null; } } return result; } /** * Finds a type in a compilation unit. Typical usage is to find the * corresponding type in a working copy. * * @param cu * the compilation unit to search in * @param typeQualifiedName * the type qualified name (type name with enclosing type names * (separated by dots)) * @return the type found, or null if not existing * @throws JavaModelException */ public static IType findTypeInCompilationUnit(ICompilationUnit cu, String typeQualifiedName) throws JavaModelException { IType[] types = cu.getAllTypes(); for (int i = 0; i < types.length; i++) { String currName = getTypeQualifiedName(types[i]); if (typeQualifiedName.equals(currName)) { return types[i]; } } return null; } /** * Finds a a member in a compilation unit. Typical usage is to find the * corresponding member in a working copy. * * @param cu * the compilation unit (eg. working copy) to search in * @param member * the member (eg. from the original) * @return the member found, or null if not existing */ public static IMember findMemberInCompilationUnit(ICompilationUnit cu, IMember member) { IJavaElement[] elements = cu.findElements(member); if (elements != null && elements.length > 0) { return (IMember) elements[0]; } return null; } /** * Returns the element of the given compilation unit which is "equal" to the * given element. Note that the given element usually has a parent different * from the given compilation unit. * * @param cu * the cu to search in * @param element * the element to look for * @return an element of the given cu "equal" to the given element */ public static IJavaElement findInCompilationUnit(ICompilationUnit cu, IJavaElement element) { IJavaElement[] elements = cu.findElements(element); if (elements != null && elements.length > 0) { return elements[0]; } return null; } /** * Returns the qualified type name of the given type using '.' as * separators. This is a replace for IType.getTypeQualifiedName() which uses * '$' as separators. As '$' is also a valid character in an id this is * ambiguous. JavaCore PR: 1GCFUNT * @param type * @return the type qualified name */ public static String getTypeQualifiedName(IType type) { return type.getTypeQualifiedName('.'); } /** * Returns the fully qualified name of the given type using '.' as * separators. This is a replace for IType.getFullyQualifiedTypeName which * uses '$' as separators. As '$' is also a valid character in an id this is * ambiguous. JavaCore PR: 1GCFUNT * @param type * @return the fully qualified name using . as the separator */ public static String getFullyQualifiedName(IType type) { return type.getFullyQualifiedName('.'); } /** * Returns the fully qualified name of a type's container. (package name or * enclosing type name) * @param type * @return the container name */ public static String getTypeContainerName(IType type) { IType outerType = type.getDeclaringType(); if (outerType != null) { return outerType.getFullyQualifiedName('.'); } return type.getPackageFragment().getElementName(); } /** * Concatenates two names. Uses a dot for separation. Both strings can be * empty or <code>null</code>. * @param name1 * @param name2 * @return name1 + name2 */ public static String concatenateName(String name1, String name2) { StringBuffer buf = new StringBuffer(); if (name1 != null && name1.length() > 0) { buf.append(name1); } if (name2 != null && name2.length() > 0) { if (buf.length() > 0) { buf.append('.'); } buf.append(name2); } return buf.toString(); } /** * Concatenates two names. Uses a dot for separation. Both strings can be * empty or <code>null</code>. * @param name1 * @param name2 * @return name1 + name2 */ public static String concatenateName(char[] name1, char[] name2) { StringBuffer buf = new StringBuffer(); if (name1 != null && name1.length > 0) { buf.append(name1); } if (name2 != null && name2.length > 0) { if (buf.length() > 0) { buf.append('.'); } buf.append(name2); } return buf.toString(); } /** * Evaluates if a member (possible from another package) is visible from * elements in a package. * * @param member * The member to test the visibility for * @param pack * The package in focus * @return true if visible * @throws JavaModelException */ public static boolean isVisible(IMember member, IPackageFragment pack) throws JavaModelException { int type = member.getElementType(); if (type == IJavaElement.INITIALIZER || (type == IJavaElement.METHOD && member.getElementName().startsWith("<"))) { //$NON-NLS-1$ //$NON-NLS-1$ return false; } int otherflags = member.getFlags(); IType declaringType = member.getDeclaringType(); if (Flags.isPublic(otherflags) || (declaringType != null && declaringType.isInterface())) { return true; } else if (Flags.isPrivate(otherflags)) { return false; } IPackageFragment otherpack = (IPackageFragment) findParentOfKind(member, IJavaElement.PACKAGE_FRAGMENT); return (pack != null && otherpack != null && isSamePackage(pack, otherpack)); } /** * Evaluates if a member in the focus' element hierarchy is visible from * elements in a package. * * @param member * The member to test the visibility for * @param pack * The package of the focus element focus * @return true if is visible in hiearchy * @throws JavaModelException */ public static boolean isVisibleInHierarchy(IMember member, IPackageFragment pack) throws JavaModelException { int type = member.getElementType(); if (type == IJavaElement.INITIALIZER || (type == IJavaElement.METHOD && member.getElementName().startsWith("<"))) { //$NON-NLS-1$ //$NON-NLS-1$ return false; } int otherflags = member.getFlags(); IType declaringType = member.getDeclaringType(); if (Flags.isPublic(otherflags) || Flags.isProtected(otherflags) || (declaringType != null && declaringType.isInterface())) { return true; } else if (Flags.isPrivate(otherflags)) { return false; } IPackageFragment otherpack = (IPackageFragment) findParentOfKind(member, IJavaElement.PACKAGE_FRAGMENT); return (pack != null && pack.equals(otherpack)); } /** * Returns the package fragment root of <code>IJavaElement</code>. If the * given element is already a package fragment root, the element itself is * returned. * @param element * @return the package fragment root */ public static IPackageFragmentRoot getPackageFragmentRoot(IJavaElement element) { return (IPackageFragmentRoot) element.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT); } /** * Returns the parent of the supplied java element that conforms to the * given parent type or <code>null</code>, if such a parent doesn't exit. * * @deprecated Use element.getParent().getAncestor(kind); */ private static IJavaElement findParentOfKind(IJavaElement element, int kind) { if (element != null && element.getParent() != null) { return element.getParent().getAncestor(kind); } return null; } /** * Finds a method in a type. This searches for a method with the same name * and 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 * The name of the method to find * @param paramTypes * The type signatures of the parameters e.g. * <code>{"QString;","I"}</code> * @param isConstructor * If the method is a constructor * @param type * @return The first found method or <code>null</code>, if nothing found * @throws JavaModelException */ public static IMethod findMethod(String name, String[] paramTypes, boolean isConstructor, IType type) throws JavaModelException { return findMethod(name, paramTypes, isConstructor, type.getMethods()); } /** * Finds a method by name. This searches for a method with a name and * 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 * The name of the method to find * @param paramTypes * The type signatures of the parameters e.g. * <code>{"QString;","I"}</code> * @param isConstructor * If the method is a constructor * @param methods * The methods to search in * @return The found method or <code>null</code>, if nothing found * @throws JavaModelException */ public static IMethod findMethod(String name, String[] paramTypes, boolean isConstructor, IMethod[] methods) throws JavaModelException { for (int i = methods.length - 1; i >= 0; i--) { if (isSameMethodSignature(name, paramTypes, isConstructor, methods[i])) { return methods[i]; } } return null; } /** * Finds a method declararion in a type's hierarchy. The search is top down, * so this returns the first declaration of the method in the hierarchy. * This searches for a method with a name and 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 hierarchy * * @param type * Searches in this type's supertypes. * @param name * The name of the method to find * @param paramTypes * The type signatures of the parameters e.g. * <code>{"QString;","I"}</code> * @param isConstructor * If the method is a constructor * @return The first method found or null, if nothing found * @throws JavaModelException */ public static IMethod findMethodDeclarationInHierarchy(ITypeHierarchy hierarchy, IType type, String name, String[] paramTypes, boolean isConstructor) throws JavaModelException { IType[] superTypes = hierarchy.getAllSupertypes(type); for (int i = superTypes.length - 1; i >= 0; i--) { IMethod first = findMethod(name, paramTypes, isConstructor, superTypes[i]); if (first != null && !Flags.isPrivate(first.getFlags())) { // the order getAllSupertypes does make assumptions of the order // of inner elements -> search recursivly IMethod res = findMethodDeclarationInHierarchy(hierarchy, first.getDeclaringType(), name, paramTypes, isConstructor); if (res != null) { return res; } return first; } } return null; } /** * Finds a method implementation in a type's classhierarchy. The search is * bottom-up, so this returns the nearest overridden method. Does not find * methods in interfaces or abstract methods. This searches for a method * with a name and 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 hierarchy * * @param type * Type to search the superclasses * @param name * The name of the method to find * @param paramTypes * The type signatures of the parameters e.g. * <code>{"QString;","I"}</code> * @param isConstructor * If the method is a constructor * @return The first method found or null, if nothing found * @throws JavaModelException */ public static IMethod findMethodImplementationInHierarchy(ITypeHierarchy hierarchy, IType type, String name, String[] paramTypes, boolean isConstructor) throws JavaModelException { IType[] superTypes = hierarchy.getAllSuperclasses(type); for (int i = 0; i < superTypes.length; i++) { IMethod found = findMethod(name, paramTypes, isConstructor, superTypes[i]); if (found != null) { if (Flags.isAbstract(found.getFlags())) { return null; } return found; } } return null; } private static IMethod findMethodInHierarchy(ITypeHierarchy hierarchy, IType type, String name, String[] paramTypes, boolean isConstructor) throws JavaModelException { IMethod method = findMethod(name, paramTypes, isConstructor, type); if (method != null) { return method; } IType superClass = hierarchy.getSuperclass(type); if (superClass != null) { IMethod res = findMethodInHierarchy(hierarchy, superClass, name, paramTypes, isConstructor); if (res != null) { return res; } } if (!isConstructor) { IType[] superInterfaces = hierarchy.getSuperInterfaces(type); for (int i = 0; i < superInterfaces.length; i++) { IMethod res = findMethodInHierarchy(hierarchy, superInterfaces[i], name, paramTypes, false); if (res != null) { return res; } } } return method; } /** * Finds the method that is defines/declares the given method. The search is * bottom-up, so this returns the nearest defining/declaring method. * @param typeHierarchy * @param type * @param methodName * @param paramTypes * @param isConstructor * * @param testVisibility * If true the result is tested on visibility. Null is returned * if the method is not visible. * @return the method or null * @throws JavaModelException */ public static IMethod findMethodDefininition(ITypeHierarchy typeHierarchy, IType type, String methodName, String[] paramTypes, boolean isConstructor, boolean testVisibility) throws JavaModelException { IType superClass = typeHierarchy.getSuperclass(type); if (superClass != null) { IMethod res = findMethodInHierarchy(typeHierarchy, superClass, methodName, paramTypes, isConstructor); if (res != null && !Flags.isPrivate(res.getFlags())) { if (!testVisibility || isVisibleInHierarchy(res, type.getPackageFragment())) { return res; } } } if (!isConstructor) { IType[] interfaces = typeHierarchy.getSuperInterfaces(type); for (int i = 0; i < interfaces.length; i++) { IMethod res = findMethodInHierarchy(typeHierarchy, interfaces[i], methodName, paramTypes, false); if (res != null) { return res; // methods from interfaces are always public and // therefore visible } } } return null; } /** * 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 isConstructor * Specifies if the method is a constructor * @param curr * @return Returns <code>true</code> if the method has the given name and * parameter types and constructor state. * @throws JavaModelException */ public static boolean isSameMethodSignature(String name, String[] paramTypes, boolean isConstructor, IMethod curr) throws JavaModelException { if (isConstructor || name.equals(curr.getElementName())) { if (isConstructor == curr.isConstructor()) { 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; } /** * Tests if two <code>IPackageFragment</code>s represent the same logical * java package. * @param pack1 * @param pack2 * * @return <code>true</code> if the package fragments' names are equal. */ public static boolean isSamePackage(IPackageFragment pack1, IPackageFragment pack2) { return pack1.getElementName().equals(pack2.getElementName()); } /** * Checks whether the given type has a valid main method or not. * @param type * @return true if type has a main method * @throws JavaModelException */ public static boolean hasMainMethod(IType type) throws JavaModelException { IMethod[] methods = type.getMethods(); for (int i = 0; i < methods.length; i++) { if (methods[i].isMainMethod()) { return true; } } return false; } /** * Checks if the field is boolean. * @param field * @return true if the file is of primitive boolean type * @throws JavaModelException */ public static boolean isBoolean(IField field) throws JavaModelException { return field.getTypeSignature().equals(Signature.SIG_BOOLEAN); } /** * Tests if the given element is on the class path of its containing * project. Handles the case that the containing project isn't a Java * project. * @param element * @return true if element in on the class path? */ public static boolean isOnClasspath(IJavaElement element) { IJavaProject project = element.getJavaProject(); if (!project.exists()) return false; return project.isOnClasspath(element); } /** * Resolves a type name in the context of the declaring type. * * @param refTypeSig * the type name in signature notation (for example 'QVector') * this can also be an array type, but dimensions will be * ignored. * @param declaringType * the context for resolving (type where the reference was made * in) * @return returns the fully qualified type name or build-in-type name. if a * unresoved type couldn't be resolved null is returned * @throws JavaModelException */ public static String getResolvedTypeName(String refTypeSig, IType declaringType) throws JavaModelException { int arrayCount = Signature.getArrayCount(refTypeSig); char type = refTypeSig.charAt(arrayCount); if (type == Signature.C_UNRESOLVED) { int semi = refTypeSig.indexOf(Signature.C_SEMICOLON, arrayCount + 1); if (semi == -1) { throw new IllegalArgumentException(); } String name = refTypeSig.substring(arrayCount + 1, semi); String[][] resolvedNames = declaringType.resolveType(name); if (resolvedNames != null && resolvedNames.length > 0) { return JavaModelUtil.concatenateName(resolvedNames[0][0], resolvedNames[0][1]); } return null; } return Signature.toString(refTypeSig.substring(arrayCount)); } /** * Returns if a CU can be edited. * @param cu * @return true if cu is editable */ public static boolean isEditable(ICompilationUnit cu) { IResource resource = toOriginal(cu).getResource(); return (resource.exists() && !resource.getResourceAttributes().isReadOnly()); } /** * Finds a qualified import for a type name. * @param cu * @param simpleName * @return the import declaration or null * @throws JavaModelException */ public static IImportDeclaration findImport(ICompilationUnit cu, String simpleName) throws JavaModelException { IImportDeclaration[] existing = cu.getImports(); for (int i = 0; i < existing.length; i++) { String curr = existing[i].getElementName(); if (curr.endsWith(simpleName)) { int dotPos = curr.length() - simpleName.length() - 1; if ((dotPos == -1) || (dotPos > 0 && curr.charAt(dotPos) == '.')) { return existing[i]; } } } return null; } /** * Returns the original if the given member. If the member is already an * original the input is returned. The returned member might not exist * @param member * @return the original IMember */ public static IMember toOriginal(IMember member) { if (member instanceof IMethod) { return toOriginalMethod((IMethod) member); } return (IMember) member.getPrimaryElement(); /* * ICompilationUnit cu= member.getCompilationUnit(); if (cu != null && * cu.isWorkingCopy()) return (IMember)cu.getOriginal(member); return * member; */ } /* * XXX workaround for bug 18568 * http://bugs.eclipse.org/bugs/show_bug.cgi?id=18568 to be removed once the * bug is fixed */ private static IMethod toOriginalMethod(IMethod method) { ICompilationUnit cu = method.getCompilationUnit(); if (cu == null || isPrimary(cu)) { return method; } try { // use the workaround only if needed if (!method.getElementName().equals(method.getDeclaringType().getElementName())) return (IMethod) method.getPrimaryElement(); IType originalType = (IType) toOriginal(method.getDeclaringType()); IMethod[] methods = originalType.findMethods(method); boolean isConstructor = method.isConstructor(); for (int i = 0; i < methods.length; i++) { if (methods[i].isConstructor() == isConstructor) return methods[i]; } return null; } catch (JavaModelException e) { return null; } } // private static boolean PRIMARY_ONLY = false; /** * Returns the original cu if the given cu is a working copy. If the cu is * already an original the input cu is returned. The returned cu might not * exist * @param cu * @return the original compiliation unit */ public static ICompilationUnit toOriginal(ICompilationUnit cu) { // To stay compatible with old version returned null // if cu is null if (cu == null) return cu; return cu.getPrimary(); } /** * Returns the original element if the given element is a working copy. If * the cu is already an original the input element is returned. The returned * element might not exist * @param element * @return element's primary element */ public static IJavaElement toOriginal(IJavaElement element) { return element.getPrimaryElement(); } /** * Returns true if a cu is a primary cu (original or shared working copy) * @param cu * @return true if cu is primary */ public static boolean isPrimary(ICompilationUnit cu) { return cu.getOwner() == null; } /** * http://bugs.eclipse.org/bugs/show_bug.cgi?id=19253 * * Reconciling happens in a separate thread. This can cause a situation * where the Java element gets disposed after an exists test has been done. * So we should not log not present exceptions when they happen in working * copies. * @param exception * @return true if filter not present */ public static boolean filterNotPresentException(CoreException exception) { if (!(exception instanceof JavaModelException)) { return true; } JavaModelException je = (JavaModelException) exception; if (!je.isDoesNotExist()) { return true; } IJavaElement[] elements = je.getJavaModelStatus().getElements(); for (int i = 0; i < elements.length; i++) { IJavaElement element = elements[i]; ICompilationUnit unit = (ICompilationUnit) element.getAncestor(IJavaElement.COMPILATION_UNIT); if (unit == null) { return true; } if (!unit.isWorkingCopy()) { return true; } } return false; } /** * @param type * @param pm * @return all supertypes of type * @throws JavaModelException */ public static IType[] getAllSuperTypes(IType type, IProgressMonitor pm) throws JavaModelException { // workaround for 23656 Set types = new HashSet(Arrays.asList(type.newSupertypeHierarchy(pm).getAllSupertypes(type))); IType objekt = type.getJavaProject().findType("java.lang.Object");//$NON-NLS-1$ if (objekt != null) { types.add(objekt); } return (IType[]) types.toArray(new IType[types.size()]); } /** * @param resourcePath * @param exclusionPatterns * @return true if resourcePath is excluded by exclusion patterns */ public static boolean isExcludedPath(IPath resourcePath, IPath[] exclusionPatterns) { char[] path = resourcePath.toString().toCharArray(); for (int i = 0, length = exclusionPatterns.length; i < length; i++) { char[] pattern = exclusionPatterns[i].toString().toCharArray(); if (CharOperation.pathMatch(pattern, path, true, '/')) { return true; } } return false; } /* * @see IClasspathEntry#getExclusionPatterns */ /** * Returns whether the given resource path matches one of the exclusion * patterns. * * @param resourcePath * @param exclusionPatterns * @return true if resourcePath is excluded */ public static boolean isExcluded(IPath resourcePath, char[][] exclusionPatterns) { if (exclusionPatterns == null) { return false; } char[] path = resourcePath.toString().toCharArray(); for (int i = 0, length = exclusionPatterns.length; i < length; i++) { if (CharOperation.pathMatch(exclusionPatterns[i], path, true, '/')) { return true; } } return false; } private static Boolean fgIsJDTCore_1_5 = null; /** * @return true if JRE 1.5 in enabled. */ public static boolean isJDTCore_1_5() { if (fgIsJDTCore_1_5 == null) { fgIsJDTCore_1_5 = JavaCore.getDefaultOptions() .containsKey("org.eclipse.jdt.core.compiler.problem.unsafeTypeOperation") ? Boolean.TRUE //$NON-NLS-1$ : Boolean.FALSE; } return fgIsJDTCore_1_5.booleanValue(); } /** * Helper method that tests if an classpath entry can be found in a * container. <code>null</code> is returned if the entry can not be found * or if the container does not allows the configuration of source * attachments * * @param jproject * The container's parent project * @param containerPath * The path of the container * @param libPath * The path of the library to be found * @return IClasspathEntry A classpath entry from the container of * <code>null</code> if the container can not be modified. * @throws JavaModelException */ public static IClasspathEntry getClasspathEntryToEdit(IJavaProject jproject, IPath containerPath, IPath libPath) throws JavaModelException { IClasspathContainer container = JavaCore.getClasspathContainer(containerPath, jproject); ClasspathContainerInitializer initializer = JavaCore .getClasspathContainerInitializer(containerPath.segment(0)); if (container != null && initializer != null && initializer.canUpdateClasspathContainer(containerPath, jproject)) { IClasspathEntry[] entries = container.getClasspathEntries(); for (int i = 0; i < entries.length; i++) { IClasspathEntry curr = entries[i]; IClasspathEntry resolved = JavaCore.getResolvedClasspathEntry(curr); if (resolved != null && libPath.equals(resolved.getPath())) { return curr; // return the real entry } } } return null; // attachment not possible } }