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

Introduction

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

Prototype

int CLASSPATH_CYCLE

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

Click Source Link

Document

Status indicating that a project is involved in a build path cycle.

Usage

From source file:org.eclipse.jdt.internal.core.JavaProject.java

License:Open Source License

public static void validateCycles(Map preferredClasspaths) throws JavaModelException {

    //long start = System.currentTimeMillis();

    IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
    IProject[] rscProjects = workspaceRoot.getProjects();
    int length = rscProjects.length;
    JavaProject[] projects = new JavaProject[length];

    LinkedHashSet cycleParticipants = new LinkedHashSet();
    HashSet traversed = new HashSet();

    // compute cycle participants
    ArrayList prereqChain = new ArrayList();
    for (int i = 0; i < length; i++) {
        if (hasJavaNature(rscProjects[i])) {
            JavaProject project = (projects[i] = (JavaProject) JavaCore.create(rscProjects[i]));
            if (!traversed.contains(project.getPath())) {
                prereqChain.clear();/*from w  w  w  .j av  a  2s . com*/
                project.updateCycleParticipants(prereqChain, cycleParticipants, workspaceRoot, traversed,
                        preferredClasspaths);
            }
        }
    }
    //System.out.println("updateAllCycleMarkers: " + (System.currentTimeMillis() - start) + " ms");

    for (int i = 0; i < length; i++) {
        JavaProject project = projects[i];
        if (project != null) {
            if (cycleParticipants.contains(project.getPath())) {
                IMarker cycleMarker = project.getCycleMarker();
                String circularCPOption = project.getOption(JavaCore.CORE_CIRCULAR_CLASSPATH, true);
                int circularCPSeverity = JavaCore.ERROR.equals(circularCPOption) ? IMarker.SEVERITY_ERROR
                        : IMarker.SEVERITY_WARNING;
                if (cycleMarker != null) {
                    // update existing cycle marker if needed
                    try {
                        int existingSeverity = ((Integer) cycleMarker.getAttribute(IMarker.SEVERITY))
                                .intValue();
                        if (existingSeverity != circularCPSeverity) {
                            cycleMarker.setAttribute(IMarker.SEVERITY, circularCPSeverity);
                        }
                    } catch (CoreException e) {
                        throw new JavaModelException(e);
                    }
                } else {
                    IJavaProject[] projectsInCycle;
                    String cycleString = ""; //$NON-NLS-1$
                    if (cycleParticipants.isEmpty()) {
                        projectsInCycle = null;
                    } else {
                        projectsInCycle = new IJavaProject[cycleParticipants.size()];
                        Iterator it = cycleParticipants.iterator();
                        int k = 0;
                        while (it.hasNext()) {
                            //projectsInCycle[i++] = (IPath) it.next();
                            IResource member = workspaceRoot.findMember((IPath) it.next());
                            if (member != null && member.getType() == IResource.PROJECT) {
                                projectsInCycle[k] = JavaCore.create((IProject) member);
                                if (projectsInCycle[k] != null) {
                                    if (k != 0)
                                        cycleString += ", "; //$NON-NLS-1$
                                    cycleString += projectsInCycle[k++].getElementName();
                                }
                            }
                        }
                    }
                    // create new marker
                    project.createClasspathProblemMarker(new JavaModelStatus(
                            IJavaModelStatusConstants.CLASSPATH_CYCLE, project, cycleString));
                }
            } else {
                project.flushClasspathProblemMarkers(true, false, false);
            }
        }
    }
}

---

From source file:org.eclipse.jdt.internal.core.JavaProject.java

License:Open Source License

/**
 * Record a new marker denoting a classpath problem
 *//*ww  w.  j  av a2 s  .co m*/
public void createClasspathProblemMarker(IJavaModelStatus status) {

    IMarker marker = null;
    int severity;
    String[] arguments = CharOperation.NO_STRINGS;
    boolean isCycleProblem = false, isClasspathFileFormatProblem = false, isOutputOverlapping = false;
    switch (status.getCode()) {

    case IJavaModelStatusConstants.CLASSPATH_CYCLE:
        isCycleProblem = true;
        if (JavaCore.ERROR.equals(getOption(JavaCore.CORE_CIRCULAR_CLASSPATH, true))) {
            severity = IMarker.SEVERITY_ERROR;
        } else {
            severity = IMarker.SEVERITY_WARNING;
        }
        break;

    case IJavaModelStatusConstants.INVALID_CLASSPATH_FILE_FORMAT:
        isClasspathFileFormatProblem = true;
        severity = IMarker.SEVERITY_ERROR;
        break;

    case IJavaModelStatusConstants.INCOMPATIBLE_JDK_LEVEL:
        String setting = getOption(JavaCore.CORE_INCOMPATIBLE_JDK_LEVEL, true);
        if (JavaCore.ERROR.equals(setting)) {
            severity = IMarker.SEVERITY_ERROR;
        } else if (JavaCore.WARNING.equals(setting)) {
            severity = IMarker.SEVERITY_WARNING;
        } else {
            return; // setting == IGNORE
        }
        break;
    case IJavaModelStatusConstants.OUTPUT_LOCATION_OVERLAPPING_ANOTHER_SOURCE:
        isOutputOverlapping = true;
        setting = getOption(JavaCore.CORE_OUTPUT_LOCATION_OVERLAPPING_ANOTHER_SOURCE, true);
        if (JavaCore.ERROR.equals(setting)) {
            severity = IMarker.SEVERITY_ERROR;
        } else if (JavaCore.WARNING.equals(setting)) {
            severity = IMarker.SEVERITY_WARNING;
        } else {
            return; // setting == IGNORE
        }
        break;
    default:
        IPath path = status.getPath();
        if (path != null)
            arguments = new String[] { path.toString() };
        if (JavaCore.ERROR.equals(getOption(JavaCore.CORE_INCOMPLETE_CLASSPATH, true))
                && status.getSeverity() != IStatus.WARNING) {
            severity = IMarker.SEVERITY_ERROR;
        } else {
            severity = IMarker.SEVERITY_WARNING;
        }
        break;
    }

    try {
        marker = this.project.createMarker(IJavaModelMarker.BUILDPATH_PROBLEM_MARKER);
        marker.setAttributes(
                new String[] { IMarker.MESSAGE, IMarker.SEVERITY, IMarker.LOCATION,
                        IJavaModelMarker.CYCLE_DETECTED, IJavaModelMarker.CLASSPATH_FILE_FORMAT,
                        IJavaModelMarker.OUTPUT_OVERLAPPING_SOURCE, IJavaModelMarker.ID,
                        IJavaModelMarker.ARGUMENTS, IJavaModelMarker.CATEGORY_ID, IMarker.SOURCE_ID, },
                new Object[] { status.getMessage(), new Integer(severity), Messages.classpath_buildPath,
                        isCycleProblem ? "true" : "false", //$NON-NLS-1$ //$NON-NLS-2$
                        isClasspathFileFormatProblem ? "true" : "false", //$NON-NLS-1$ //$NON-NLS-2$
                        isOutputOverlapping ? "true" : "false", //$NON-NLS-1$ //$NON-NLS-2$
                        new Integer(status.getCode()), Util.getProblemArgumentsForMarker(arguments),
                        new Integer(CategorizedProblem.CAT_BUILDPATH), JavaBuilder.SOURCE_ID, });
    } catch (CoreException e) {
        // could not create marker: cannot do much
        if (JavaModelManager.VERBOSE) {
            e.printStackTrace();
        }
    }
}

---