Example usage for org.eclipse.jdt.core IJavaModelStatusConstants CP_VARIABLE_PATH

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IJavaModelStatusConstants CP_VARIABLE_PATH_UNBOUND.

Prototype

int CP_VARIABLE_PATH_UNBOUND

To view the source code for org.eclipse.jdt.core IJavaModelStatusConstants CP_VARIABLE_PATH_UNBOUND.

Click Source Link

Document

Status constant indicating that a variable path was not resolvable indicating either the referred variable is undefined, unbound or the resolved variable path does not correspond to an existing file or folder.

Usage

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 ww.  ja  v a  2s . c  om*/
                        .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;
}

Example usage for org.eclipse.jdt.core IJavaModelStatusConstants CP_VARIABLE_PATH_UNBOUND

Introduction

Prototype

Document

Usage