List of usage examples for org.eclipse.jdt.core IClasspathEntry CPE_VARIABLE
int CPE_VARIABLE
To view the source code for org.eclipse.jdt.core IClasspathEntry CPE_VARIABLE.
Click Source Link
From source file:org.eclipse.e4.xwt.tools.ui.designer.jdt.ProjectHelper.java
License:Open Source License
protected static boolean containsJar(IJavaProject javaProject, IClasspathEntry entry, String jarName) { switch (entry.getEntryKind()) { case IClasspathEntry.CPE_VARIABLE: IClasspathEntry resolvedEntry = JavaCore.getJavaCore().getResolvedClasspathEntry(entry); IPath resolvedPath = resolvedEntry.getPath(); String string = resolvedPath.toString(); if (string.indexOf(jarName) != -1) { return true; }/* ww w. ja va 2 s. c om*/ break; case IClasspathEntry.CPE_CONTAINER: try { IPath path = entry.getPath(); IClasspathContainer classpathContainer = JavaCore.getJavaCore().getClasspathContainer(path, javaProject); if (classpathContainer != null) { classpathContainer.getClasspathEntries(); IClasspathEntry[] oldclasspath = classpathContainer.getClasspathEntries(); for (int i = 0; i < oldclasspath.length; i++) { if (containsJar(javaProject, oldclasspath[i], jarName)) { return true; } } } } catch (JavaModelException e) { // TODO Auto-generated catch block e.printStackTrace(); } break; case IClasspathEntry.CPE_SOURCE: case IClasspathEntry.CPE_LIBRARY: IPath path = entry.getPath(); String value = path.toString(); if (value.indexOf(jarName) != -1) { return true; } } return false; }
From source file:org.eclipse.edt.ide.ui.internal.property.pages.VariableBlock.java
License:Open Source License
private boolean doesChangeRequireFullBuild(List removed, List changed) { try {//w w w . ja v a2 s .com IJavaModel model = JavaCore.create(ResourcesPlugin.getWorkspace().getRoot()); IJavaProject[] projects = model.getJavaProjects(); for (int i = 0; i < projects.length; i++) { IClasspathEntry[] entries = projects[i].getRawClasspath(); for (int k = 0; k < entries.length; k++) { IClasspathEntry curr = entries[k]; if (curr.getEntryKind() == IClasspathEntry.CPE_VARIABLE) { String var = curr.getPath().segment(0); if (removed.contains(var) || changed.contains(var)) { return true; } } } } } catch (JavaModelException e) { return true; } return false; }
From source file:org.eclipse.emf.ecore.xcore.ui.XcoreJavaProjectProvider.java
License:Open Source License
public ClassLoader getClassLoader(ResourceSet resourceSet) { IJavaProject project = getJavaProject(resourceSet); if (project != null) { IProject iProject = project.getProject(); IWorkspaceRoot workspaceRoot = iProject.getWorkspace().getRoot(); List<URL> libraryURLs = new UniqueEList<URL>(); try {//from w w w. j a v a 2 s . c o m getAllReferencedProjects(libraryURLs, new IProject[] { iProject }); IClasspathEntry[] classpath = project.getResolvedClasspath(true); if (classpath != null) { String projectName = iProject.getName(); for (int i = 0; i < classpath.length; ++i) { IClasspathEntry classpathEntry = classpath[i]; switch (classpathEntry.getEntryKind()) { case IClasspathEntry.CPE_LIBRARY: case IClasspathEntry.CPE_CONTAINER: { IPath path = classpathEntry.getPath(); if (path.segment(0).equals(projectName)) { path = iProject.getLocation().append(path.removeFirstSegments(1)); } libraryURLs.add(new URL(URI.createFileURI(path.toString()).toString())); break; } case IClasspathEntry.CPE_PROJECT: { IPath path = classpathEntry.getPath(); IProject referencedProject = workspaceRoot.getProject(path.segment(0)); IJavaProject referencedJavaProject = JavaCore.create(referencedProject); IContainer container = workspaceRoot .getFolder(referencedJavaProject.getOutputLocation()); libraryURLs.add(new URL( URI.createFileURI(container.getLocation().toString() + "/").toString())); IProjectDescription description = referencedProject.getDescription(); getAllReferencedProjects(libraryURLs, description.getReferencedProjects()); getAllReferencedProjects(libraryURLs, description.getDynamicReferences()); break; } case IClasspathEntry.CPE_SOURCE: case IClasspathEntry.CPE_VARIABLE: default: { break; } } } } return new URLClassLoader(libraryURLs.toArray(new URL[libraryURLs.size()]), getClass().getClassLoader()); } catch (MalformedURLException exception) { exception.printStackTrace(); } catch (JavaModelException exception) { exception.printStackTrace(); } catch (CoreException exception) { exception.printStackTrace(); } } for (Resource resource : resourceSet.getResources()) { URI uri = resource.getURI(); if (uri.isPlatformPlugin()) { final Bundle bundle = Platform.getBundle(uri.segments()[1]); return new ClassLoader() { @Override public Enumeration<URL> findResources(String name) throws IOException { return bundle.getResources(name); } @Override public URL findResource(String name) { return bundle.getResource(name); } @Override public URL getResource(String name) { return findResource(name); } @Override public Class<?> findClass(String name) throws ClassNotFoundException { return bundle.loadClass(name); } @Override protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { Class<?> clazz = findClass(name); if (resolve) { resolveClass(clazz); } return clazz; } }; } } return null; }
From source file:org.eclipse.emf.java.presentation.JavaEditor.java
License:Open Source License
public void setupClassLoader(IProject project) { JavaPackageResourceImpl javaPackageResource = (JavaPackageResourceImpl) editingDomain .loadResource(JavaUtil.JAVA_PACKAGE_RESOURCE); IWorkspaceRoot workspaceRoot = project.getWorkspace().getRoot(); List<URL> libraryURLs = new UniqueEList<URL>(); List<String> sourceURIs = new ArrayList<String>(); try {//from w w w. j a v a 2 s . c om IJavaProject javaProject = JavaCore.create(project); IClasspathEntry[] classpath = javaProject.getResolvedClasspath(true); if (classpath != null) { for (int i = 0; i < classpath.length; ++i) { IClasspathEntry classpathEntry = classpath[i]; switch (classpathEntry.getEntryKind()) { case IClasspathEntry.CPE_LIBRARY: case IClasspathEntry.CPE_CONTAINER: { libraryURLs.add(new URL(URI.createFileURI(classpathEntry.getPath().toString()).toString())); break; } case IClasspathEntry.CPE_SOURCE: { sourceURIs.add( URI.createPlatformResourceURI(classpathEntry.getPath().toString(), true) + "/"); break; } case IClasspathEntry.CPE_PROJECT: { IProject referencedProject = workspaceRoot.getProject(classpathEntry.getPath().segment(0)); IJavaProject referencedJavaProject = JavaCore.create(referencedProject); IContainer container = workspaceRoot.getFolder(referencedJavaProject.getOutputLocation()); libraryURLs.add( new URL(URI.createFileURI(container.getLocation().toString() + "/").toString())); getAllReferencedProjects(libraryURLs, referencedProject.getDescription().getReferencedProjects()); getAllReferencedProjects(libraryURLs, referencedProject.getDescription().getDynamicReferences()); break; } case IClasspathEntry.CPE_VARIABLE: default: { break; } } } } javaPackageResource.setClassLoader(new URLClassLoader(libraryURLs.toArray(new URL[libraryURLs.size()]), new URLClassLoader(new URL[0], null))); javaPackageResource.getSourceURIs().addAll(sourceURIs); } catch (MalformedURLException exception) { exception.printStackTrace(); } catch (JavaModelException exception) { exception.printStackTrace(); } catch (CoreException exception) { exception.printStackTrace(); } }
From source file:org.eclipse.jdt.internal.core.JavaModelManager.java
License:Open Source License
public IClasspathEntry resolveVariableEntry(IClasspathEntry entry, boolean usePreviousSession) { if (entry.getEntryKind() != IClasspathEntry.CPE_VARIABLE) return entry; IPath resolvedPath = getResolvedVariablePath(entry.getPath(), usePreviousSession); if (resolvedPath == null) return null; // By passing a null reference path, we keep it relative to workspace root. resolvedPath = ClasspathEntry.resolveDotDot(null, resolvedPath); Object target = JavaModel.getTarget(resolvedPath, false); if (target == null) return null; // inside the workspace if (target instanceof IResource) { IResource resolvedResource = (IResource) target; switch (resolvedResource.getType()) { case IResource.PROJECT: // internal project return JavaCore.newProjectEntry(resolvedPath, entry.getAccessRules(), entry.combineAccessRules(), entry.getExtraAttributes(), entry.isExported()); case IResource.FILE: // internal binary archive return JavaCore.newLibraryEntry(resolvedPath, getResolvedVariablePath(entry.getSourceAttachmentPath(), usePreviousSession), getResolvedVariablePath(entry.getSourceAttachmentRootPath(), usePreviousSession), entry.getAccessRules(), entry.getExtraAttributes(), entry.isExported()); case IResource.FOLDER: // internal binary folder return JavaCore.newLibraryEntry(resolvedPath, getResolvedVariablePath(entry.getSourceAttachmentPath(), usePreviousSession), getResolvedVariablePath(entry.getSourceAttachmentRootPath(), usePreviousSession), entry.getAccessRules(), entry.getExtraAttributes(), entry.isExported()); }//from www. j a va2 s .co m } if (target instanceof File) { File externalFile = JavaModel.getFile(target); if (externalFile != null) { // external binary archive return JavaCore.newLibraryEntry(resolvedPath, getResolvedVariablePath(entry.getSourceAttachmentPath(), usePreviousSession), getResolvedVariablePath(entry.getSourceAttachmentRootPath(), usePreviousSession), entry.getAccessRules(), entry.getExtraAttributes(), entry.isExported()); } else { // non-existing file if (resolvedPath.isAbsolute()) { return JavaCore.newLibraryEntry(resolvedPath, getResolvedVariablePath(entry.getSourceAttachmentPath(), usePreviousSession), getResolvedVariablePath(entry.getSourceAttachmentRootPath(), usePreviousSession), entry.getAccessRules(), entry.getExtraAttributes(), entry.isExported()); } } } return null; }
From source file:org.eclipse.jdt.internal.core.JavaProject.java
License:Open Source License
public ResolvedClasspath resolveClasspath(IClasspathEntry[] rawClasspath, IClasspathEntry[] referencedEntries, boolean usePreviousSession, boolean resolveChainedLibraries) throws JavaModelException { JavaModelManager manager = JavaModelManager.getJavaModelManager(); ExternalFoldersManager externalFoldersManager = JavaModelManager.getExternalManager(); ResolvedClasspath result = new ResolvedClasspath(); Map knownDrives = new HashMap(); Map referencedEntriesMap = new HashMap(); List rawLibrariesPath = new ArrayList(); LinkedHashSet resolvedEntries = new LinkedHashSet(); if (resolveChainedLibraries) { for (int index = 0; index < rawClasspath.length; index++) { IClasspathEntry currentEntry = rawClasspath[index]; if (currentEntry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) { rawLibrariesPath//from w w w .jav a 2s . c o m .add(ClasspathEntry.resolveDotDot(getProject().getLocation(), currentEntry.getPath())); } } if (referencedEntries != null) { // The Set is required to keep the order intact while the referencedEntriesMap (Map) // is used to map the referenced entries with path LinkedHashSet referencedEntriesSet = new LinkedHashSet(); for (int index = 0; index < referencedEntries.length; index++) { IPath path = referencedEntries[index].getPath(); if (!rawLibrariesPath.contains(path) && referencedEntriesMap.get(path) == null) { referencedEntriesMap.put(path, referencedEntries[index]); referencedEntriesSet.add(referencedEntries[index]); } } if (referencedEntriesSet.size() > 0) { result.referencedEntries = new IClasspathEntry[referencedEntriesSet.size()]; referencedEntriesSet.toArray(result.referencedEntries); } } } int length = rawClasspath.length; for (int i = 0; i < length; i++) { IClasspathEntry rawEntry = rawClasspath[i]; IClasspathEntry resolvedEntry = rawEntry; switch (rawEntry.getEntryKind()) { case IClasspathEntry.CPE_VARIABLE: try { resolvedEntry = manager.resolveVariableEntry(rawEntry, usePreviousSession); } catch (ClasspathEntry.AssertionFailedException e) { // Catch the assertion failure and set status instead // see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=55992 result.unresolvedEntryStatus = new JavaModelStatus(IJavaModelStatusConstants.INVALID_PATH, e.getMessage()); break; } if (resolvedEntry == null) { result.unresolvedEntryStatus = new JavaModelStatus( IJavaModelStatusConstants.CP_VARIABLE_PATH_UNBOUND, this, rawEntry.getPath()); } else { // If the entry is already present in the rawReversetMap, it means the entry and the chained libraries // have already been processed. So, skip it. if (resolveChainedLibraries && resolvedEntry.getEntryKind() == IClasspathEntry.CPE_LIBRARY && result.rawReverseMap.get(resolvedEntry.getPath()) == null) { // resolve Class-Path: in manifest ClasspathEntry[] extraEntries = ((ClasspathEntry) resolvedEntry).resolvedChainedLibraries(); for (int j = 0, length2 = extraEntries.length; j < length2; j++) { if (!rawLibrariesPath.contains(extraEntries[j].getPath())) { // https://bugs.eclipse.org/bugs/show_bug.cgi?id=305037 // referenced entries for variable entries could also be persisted with extra attributes, so addAsChainedEntry = true addToResult(rawEntry, extraEntries[j], result, resolvedEntries, externalFoldersManager, referencedEntriesMap, true, knownDrives); } } } addToResult(rawEntry, resolvedEntry, result, resolvedEntries, externalFoldersManager, referencedEntriesMap, false, knownDrives); } break; case IClasspathEntry.CPE_CONTAINER: IClasspathContainer container = usePreviousSession ? manager.getPreviousSessionContainer(rawEntry.getPath(), this) : JavaCore.getClasspathContainer(rawEntry.getPath(), this); if (container == null) { result.unresolvedEntryStatus = new JavaModelStatus( IJavaModelStatusConstants.CP_CONTAINER_PATH_UNBOUND, this, rawEntry.getPath()); break; } IClasspathEntry[] containerEntries = container.getClasspathEntries(); if (containerEntries == null) { if (JavaModelManager.CP_RESOLVE_VERBOSE || JavaModelManager.CP_RESOLVE_VERBOSE_FAILURE) { JavaModelManager.getJavaModelManager().verbose_missbehaving_container_null_entries(this, rawEntry.getPath()); } break; } // container was bound for (int j = 0, containerLength = containerEntries.length; j < containerLength; j++) { ClasspathEntry cEntry = (ClasspathEntry) containerEntries[j]; if (cEntry == null) { if (JavaModelManager.CP_RESOLVE_VERBOSE || JavaModelManager.CP_RESOLVE_VERBOSE_FAILURE) { JavaModelManager.getJavaModelManager().verbose_missbehaving_container(this, rawEntry.getPath(), containerEntries); } break; } // if container is exported or restricted, then its nested entries must in turn be exported (21749) and/or propagate restrictions cEntry = cEntry.combineWith((ClasspathEntry) rawEntry); if (cEntry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) { // resolve ".." in library path cEntry = cEntry.resolvedDotDot(getProject().getLocation()); // https://bugs.eclipse.org/bugs/show_bug.cgi?id=313965 // Do not resolve if the system attribute is set to false if (resolveChainedLibraries && JavaModelManager.getJavaModelManager().resolveReferencedLibrariesForContainers && result.rawReverseMap.get(cEntry.getPath()) == null) { // resolve Class-Path: in manifest ClasspathEntry[] extraEntries = cEntry.resolvedChainedLibraries(); for (int k = 0, length2 = extraEntries.length; k < length2; k++) { if (!rawLibrariesPath.contains(extraEntries[k].getPath())) { addToResult(rawEntry, extraEntries[k], result, resolvedEntries, externalFoldersManager, referencedEntriesMap, false, knownDrives); } } } } addToResult(rawEntry, cEntry, result, resolvedEntries, externalFoldersManager, referencedEntriesMap, false, knownDrives); } break; case IClasspathEntry.CPE_LIBRARY: // resolve ".." in library path resolvedEntry = ((ClasspathEntry) rawEntry).resolvedDotDot(getProject().getLocation()); if (resolveChainedLibraries && result.rawReverseMap.get(resolvedEntry.getPath()) == null) { // resolve Class-Path: in manifest ClasspathEntry[] extraEntries = ((ClasspathEntry) resolvedEntry).resolvedChainedLibraries(); for (int k = 0, length2 = extraEntries.length; k < length2; k++) { if (!rawLibrariesPath.contains(extraEntries[k].getPath())) { addToResult(rawEntry, extraEntries[k], result, resolvedEntries, externalFoldersManager, referencedEntriesMap, true, knownDrives); } } } addToResult(rawEntry, resolvedEntry, result, resolvedEntries, externalFoldersManager, referencedEntriesMap, false, knownDrives); break; default: addToResult(rawEntry, resolvedEntry, result, resolvedEntries, externalFoldersManager, referencedEntriesMap, false, knownDrives); break; } } result.resolvedClasspath = new IClasspathEntry[resolvedEntries.size()]; resolvedEntries.toArray(result.resolvedClasspath); return result; }
From source file:org.eclipse.jem.internal.beaninfo.core.BeaninfoEntry.java
License:Open Source License
static int kindFromString(String kindStr) { if (kindStr == null || kindStr.length() == 0) return BIE_PLUGIN; // Default to plugin. If coming from beaninfoconfig, there should always be kind. But if coming from plugin.xml there shouldn't be one. if (kindStr.equalsIgnoreCase("con")) //$NON-NLS-1$ return IClasspathEntry.CPE_CONTAINER; if (kindStr.equalsIgnoreCase("var")) //$NON-NLS-1$ return IClasspathEntry.CPE_VARIABLE; if (kindStr.equalsIgnoreCase("src")) //$NON-NLS-1$ return IClasspathEntry.CPE_SOURCE; if (kindStr.equalsIgnoreCase("lib")) //$NON-NLS-1$ return IClasspathEntry.CPE_LIBRARY; if (kindStr.equalsIgnoreCase("plugin")) //$NON-NLS-1$ return BIE_PLUGIN; return -1;/* w w w. j a v a 2 s . c o m*/ }
From source file:org.eclipse.jem.internal.beaninfo.core.BeaninfoEntry.java
License:Open Source License
static String kindToString(int kind) { switch (kind) { case IClasspathEntry.CPE_PROJECT: return "src"; // backward compatibility //$NON-NLS-1$ case IClasspathEntry.CPE_SOURCE: return "src"; //$NON-NLS-1$ case IClasspathEntry.CPE_LIBRARY: return "lib"; //$NON-NLS-1$ case IClasspathEntry.CPE_VARIABLE: return "var"; //$NON-NLS-1$ case IClasspathEntry.CPE_CONTAINER: return "con"; //$NON-NLS-1$ case BIE_PLUGIN: return "plugin"; //$NON-NLS-1$ default:/*from w w w . j a v a 2 s. com*/ return "unknown"; //$NON-NLS-1$ } }
From source file:org.eclipse.jem.internal.beaninfo.core.BeaninfoEntry.java
License:Open Source License
/** * Return the appropriate kind of entry when we know it is a classpath entry. *///from ww w . j a va 2 s . co m public static IClasspathEntry createEntry(int kind, IPath path, IProject project, boolean isExported) { switch (kind) { case IClasspathEntry.CPE_LIBRARY: if (path.isAbsolute()) return JavaCore.newLibraryEntry(path, null, null, isExported); break; case IClasspathEntry.CPE_SOURCE: if (path.isAbsolute()) { // must be an entry in this project or specify another project String projSegment = path.segment(0); if (project != null && projSegment != null && projSegment.equals(project.getName())) { // this project return JavaCore.newSourceEntry(path); } else { // another project return JavaCore.newProjectEntry(path, isExported); } } break; case IClasspathEntry.CPE_VARIABLE: return JavaCore.newVariableEntry(path, null, null, isExported); case IClasspathEntry.CPE_CONTAINER: return JavaCore.newContainerEntry(path, isExported); } return null; }
From source file:org.eclipse.jem.internal.beaninfo.core.BeaninfoEntry.java
License:Open Source License
/** * Read the entry in from the element.//from ww w . j a va 2 s .c om */ public static BeaninfoEntry readEntry(IReader reader, Object element, IProject project) { String elementKind = reader.getAttribute(element, BeaninfosDoc.sKind); String pathStr = reader.getAttribute(element, BeaninfosDoc.sPath); // ensure path is absolute IPath path = new Path(pathStr); int kind = kindFromString(elementKind); if (kind != IClasspathEntry.CPE_VARIABLE && kind != IClasspathEntry.CPE_CONTAINER && kind != BIE_PLUGIN && !path.isAbsolute()) { path = project != null ? project.getFullPath().append(path) : path.makeAbsolute(); // Some folder/jar within this project } // exported flag String exportedString = reader.getAttribute(element, BeaninfosDoc.sExported); boolean isExported = "true".equalsIgnoreCase(exportedString); //$NON-NLS-1$ //$NON-NLS-1$ // recreate the entry IClasspathEntry cpEntry = null; IPath pluginPath = null; if (kind != BIE_PLUGIN) { cpEntry = createEntry(kind, path, project, isExported); } else { if (path.isAbsolute()) pluginPath = path; else { // Kludge This should only be a plugin type if from configuration element. So we will cast to that // and get the plugin id to create an absolute plugin path. if (element instanceof IConfigurationElement) { pluginPath = new Path('/' + ((IConfigurationElement) element).getDeclaringExtension().getContributor().getName()) .append(path); } else return null; // Not valid because can't have plugin from .beaninfoconfig file. } } ArrayList searchpaths = new ArrayList(); Object children = reader.getChildren(element); int childrenLength = reader.getLength(children); for (int i = 0; i < childrenLength; i++) { Object child = reader.getItem(children, i); if (reader.isNodeTypeElement(child)) { Object entry = null; if (reader.getNodeName(child).equalsIgnoreCase(SearchpathEntry.sSearchpath)) { entry = SearchpathEntry.readEntry(reader, child, project, true); } if (entry != null) searchpaths.add(entry); } } if (cpEntry != null) return new BeaninfoEntry(cpEntry, (SearchpathEntry[]) searchpaths.toArray(new SearchpathEntry[searchpaths.size()]), isExported); else return new BeaninfoEntry(pluginPath, (SearchpathEntry[]) searchpaths.toArray(new SearchpathEntry[searchpaths.size()]), isExported); }