Examples with IClasspathAttribute org.eclipse.jdt.core.IClasspathAttribute used on opensource projects

Example 1 with IClasspathAttribute

use of org.eclipse.jdt.core.IClasspathAttribute in project che by eclipse.

the class ClasspathEntryHelper method setClasspathEntry.

//Copied from org.eclipse.m2e.jdt.internal.ClasspathEntryDescriptor
private void setClasspathEntry(IClasspathEntry entry) {
    this.kind = entry.getEntryKind();
    this.path = entry.getPath();
    this.exported = entry.isExported();
    this.outputLocation = entry.getOutputLocation();
    this.accessRules = new ArrayList<>();
    for (IAccessRule rule : entry.getAccessRules()) {
        this.accessRules.add(rule);
    }
    this.attributes = new HashMap<>();
    for (IClasspathAttribute attribute : entry.getExtraAttributes()) {
        attributes.put(attribute.getName(), attribute.getValue());
    }
    this.sourcePath = entry.getSourceAttachmentPath();
    this.sourceRootPath = entry.getSourceAttachmentRootPath();
    setInclusionPatterns(entry.getInclusionPatterns());
    setExclusionPatterns(entry.getExclusionPatterns());
    this.combineAccessRules = entry.combineAccessRules();
    String groupId = attributes.get(ClasspathManager.GROUP_ID_ATTRIBUTE);
    String artifactId = attributes.get(ClasspathManager.ARTIFACT_ID_ATTRIBUTE);
    String version = attributes.get(ClasspathManager.VERSION_ATTRIBUTE);
    String packaging = attributes.get(ClasspathManager.PACKAGING_ATTRIBUTE);
    String classifier = attributes.get(ClasspathManager.CLASSIFIER_ATTRIBUTE);
    if (groupId != null && artifactId != null && version != null) {
        this.artifactKey = new MavenArtifactKey(groupId, artifactId, version, packaging, classifier);
    }
}

Example 2 with IClasspathAttribute

use of org.eclipse.jdt.core.IClasspathAttribute in project che by eclipse.

the class ClasspathEntryHelper method toClasspathEntry.

//Copied from org.eclipse.m2e.jdt.internal.ClasspathEntryDescriptor
public IClasspathEntry toClasspathEntry() {
    Map<String, String> attributes = new HashMap<String, String>(this.attributes);
    if (artifactKey != null) {
        attributes.put(ClasspathManager.GROUP_ID_ATTRIBUTE, artifactKey.getGroupId());
        attributes.put(ClasspathManager.ARTIFACT_ID_ATTRIBUTE, artifactKey.getArtifactId());
        attributes.put(ClasspathManager.VERSION_ATTRIBUTE, artifactKey.getVersion());
        attributes.put(ClasspathManager.PACKAGING_ATTRIBUTE, artifactKey.getPackaging());
        if (artifactKey.getClassifier() != null) {
            attributes.put(ClasspathManager.CLASSIFIER_ATTRIBUTE, artifactKey.getClassifier());
        }
    }
    IClasspathAttribute[] attributesArray = new IClasspathAttribute[attributes.size()];
    int attributeIndex = 0;
    for (Map.Entry<String, String> attribute : attributes.entrySet()) {
        attributesArray[attributeIndex++] = JavaCore.newClasspathAttribute(attribute.getKey(), attribute.getValue());
    }
    IAccessRule[] accessRulesArray = accessRules.toArray(new IAccessRule[accessRules.size()]);
    IClasspathEntry entry;
    switch(kind) {
        case IClasspathEntry.CPE_CONTAINER:
            entry = //
            JavaCore.newContainerEntry(//
            path, //
            accessRulesArray, //
            attributesArray, exported);
            break;
        case IClasspathEntry.CPE_LIBRARY:
            entry = //
            JavaCore.newLibraryEntry(//
            path, //
            sourcePath, //
            sourceRootPath, //
            accessRulesArray, //
            attributesArray, exported);
            break;
        case IClasspathEntry.CPE_SOURCE:
            entry = //
            JavaCore.newSourceEntry(//
            path, //
            getInclusionPatterns(), //
            getExclusionPatterns(), //
            outputLocation, attributesArray);
            break;
        case IClasspathEntry.CPE_PROJECT:
            entry = //
            JavaCore.newProjectEntry(//
            path, //
            accessRulesArray, //
            combineAccessRules, //
            attributesArray, exported);
            break;
        case IClasspathEntry.CPE_VARIABLE:
            entry = //
            JavaCore.newVariableEntry(//
            path, //
            sourcePath, //
            sourceRootPath, //
            accessRulesArray, //
            attributesArray, exported);
            break;
        default:
            //$NON-NLS-1$
            throw new IllegalArgumentException("Unsupported IClasspathEntry kind=" + kind);
    }
    return entry;
}

Example 3 with IClasspathAttribute

use of org.eclipse.jdt.core.IClasspathAttribute in project che by eclipse.

the class ClasspathManager method getArtifactKey.

private MavenArtifactKey getArtifactKey(IClasspathEntry classpathEntry) {
    IClasspathAttribute[] attributes = classpathEntry.getExtraAttributes();
    String groupId = null;
    String artifactId = null;
    String version = null;
    String packaging = null;
    String classifier = null;
    for (IClasspathAttribute attribute : attributes) {
        if (ClasspathManager.GROUP_ID_ATTRIBUTE.equals(attribute.getName())) {
            groupId = attribute.getValue();
        } else if (ClasspathManager.ARTIFACT_ID_ATTRIBUTE.equals(attribute.getName())) {
            artifactId = attribute.getValue();
        } else if (ClasspathManager.VERSION_ATTRIBUTE.equals(attribute.getName())) {
            version = attribute.getValue();
        } else if (ClasspathManager.PACKAGING_ATTRIBUTE.equals(attribute.getName())) {
            packaging = attribute.getValue();
        } else if (ClasspathManager.CLASSIFIER_ATTRIBUTE.equals(attribute.getName())) {
            classifier = attribute.getValue();
        }
    }
    if (groupId != null && artifactId != null && version != null) {
        return new MavenArtifactKey(groupId, artifactId, version, packaging, classifier);
    }
    return null;
}

Example 4 with IClasspathAttribute

use of org.eclipse.jdt.core.IClasspathAttribute in project che by eclipse.

the class ClasspathEntry method validateClasspathEntry.

//	/**
//	 * Returns a Java model status describing the problem related to this classpath entry if any,
//	 * a status object with code <code>IStatus.OK</code> if the entry is fine (that is, if the
//	 * given classpath entry denotes a valid element to be referenced onto a classpath).
//	 *
//	 * @param project the given java project
//	 * @param entry the given classpath entry
//	 * @param checkSourceAttachment a flag to determine if source attachment should be checked
//	 * @param referredByContainer flag indicating whether the given entry is referred by a classpath container
//	 * @return a java model status describing the problem related to this classpath entry if any, a status object with code <code>IStatus
// .OK</code> if the entry is fine
//	 */
//	public static IJavaModelStatus validateClasspathEntry(IJavaProject project, IClasspathEntry entry, boolean checkSourceAttachment,
// boolean referredByContainer){
//		if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
//			JavaModelManager.getJavaModelManager().removeFromInvalidArchiveCache(entry.getPath());
//		}
//		IJavaModelStatus status = validateClasspathEntry(project, entry, null, checkSourceAttachment, referredByContainer);
//		// https://bugs.eclipse.org/bugs/show_bug.cgi?id=171136 and https://bugs.eclipse.org/bugs/show_bug.cgi?id=300136
//		// Ignore class path errors from optional entries.
//		int statusCode = status.getCode();
//		if ( (statusCode == IJavaModelStatusConstants.INVALID_CLASSPATH ||
//				statusCode == IJavaModelStatusConstants.CP_CONTAINER_PATH_UNBOUND ||
//				statusCode == IJavaModelStatusConstants.CP_VARIABLE_PATH_UNBOUND ||
//				statusCode == IJavaModelStatusConstants.INVALID_PATH) &&
//				((ClasspathEntry) entry).isOptional())
//			return JavaModelStatus.VERIFIED_OK;
//		return status;
//	}
private static IJavaModelStatus validateClasspathEntry(IJavaProject project, IClasspathEntry entry, IClasspathContainer entryContainer, boolean checkSourceAttachment, boolean referredByContainer) {
    IPath path = entry.getPath();
    // Build some common strings for status message
    String projectName = project.getElementName();
    String entryPathMsg = projectName.equals(path.segment(0)) ? path.removeFirstSegments(1).makeRelative().toString() : path.toString();
    switch(entry.getEntryKind()) {
        // container entry check
        case IClasspathEntry.CPE_CONTAINER:
            if (path.segmentCount() >= 1) {
                try {
                    IJavaModelStatus status = null;
                    // Validate extra attributes
                    IClasspathAttribute[] extraAttributes = entry.getExtraAttributes();
                    if (extraAttributes != null) {
                        int length = extraAttributes.length;
                        HashSet set = new HashSet(length);
                        for (int i = 0; i < length; i++) {
                            String attName = extraAttributes[i].getName();
                            if (!set.add(attName)) {
                                status = new JavaModelStatus(IJavaModelStatusConstants.NAME_COLLISION, Messages.bind(Messages.classpath_duplicateEntryExtraAttribute, new String[] { attName, entryPathMsg, projectName }));
                                break;
                            }
                        }
                    }
                    IClasspathContainer container = JavaModelManager.getJavaModelManager().getClasspathContainer(path, project);
                    // container retrieval is performing validation check on container entry kinds.
                    if (container == null) {
                        if (status != null)
                            return status;
                        return new JavaModelStatus(IJavaModelStatusConstants.CP_CONTAINER_PATH_UNBOUND, project, path);
                    } else if (container == JavaModelManager.CONTAINER_INITIALIZATION_IN_PROGRESS) {
                        // don't create a marker if initialization is in progress (case of cp initialization batching)
                        return JavaModelStatus.VERIFIED_OK;
                    }
                    IClasspathEntry[] containerEntries = container.getClasspathEntries();
                    if (containerEntries != null) {
                        for (int i = 0, length = containerEntries.length; i < length; i++) {
                            IClasspathEntry containerEntry = containerEntries[i];
                            int kind = containerEntry == null ? 0 : containerEntry.getEntryKind();
                            if (containerEntry == null || kind == IClasspathEntry.CPE_SOURCE || kind == IClasspathEntry.CPE_VARIABLE || kind == IClasspathEntry.CPE_CONTAINER) {
                                return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CP_CONTAINER_ENTRY, project, path);
                            }
                            IJavaModelStatus containerEntryStatus = validateClasspathEntry(project, containerEntry, container, checkSourceAttachment, true);
                            if (!containerEntryStatus.isOK()) {
                                return containerEntryStatus;
                            }
                        }
                    }
                } catch (JavaModelException e) {
                    return new JavaModelStatus(e);
                }
            } else {
                return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_illegalContainerPath, new String[] { entryPathMsg, projectName }));
            }
            break;
        // variable entry check
        case IClasspathEntry.CPE_VARIABLE:
            if (path.segmentCount() >= 1) {
                try {
                    entry = JavaCore.getResolvedClasspathEntry(entry);
                } catch (AssertionFailedException e) {
                    // see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=55992
                    return new JavaModelStatus(IJavaModelStatusConstants.INVALID_PATH, e.getMessage());
                }
                if (entry == null) {
                    return new JavaModelStatus(IJavaModelStatusConstants.CP_VARIABLE_PATH_UNBOUND, project, path);
                }
                // get validation status
                IJavaModelStatus status = validateClasspathEntry(project, entry, null, checkSourceAttachment, false);
                if (!status.isOK())
                    return status;
                // return deprecation status if any
                String variableName = path.segment(0);
                String deprecatedMessage = JavaCore.getClasspathVariableDeprecationMessage(variableName);
                if (deprecatedMessage != null) {
                    return new JavaModelStatus(IStatus.WARNING, IJavaModelStatusConstants.DEPRECATED_VARIABLE, project, path, deprecatedMessage);
                }
                return status;
            } else {
                return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_illegalVariablePath, new String[] { entryPathMsg, projectName }));
            }
        // library entry check
        case IClasspathEntry.CPE_LIBRARY:
            path = ClasspathEntry.resolveDotDot(project.getProject().getLocation(), path);
            // do not validate entries from Class-Path: in manifest
            // (these entries are considered optional since the user cannot act on them)
            // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=252392
            String containerInfo = null;
            if (entryContainer != null) {
                if (entryContainer instanceof UserLibraryClasspathContainer) {
                    containerInfo = Messages.bind(Messages.classpath_userLibraryInfo, new String[] { entryContainer.getDescription() });
                } else {
                    containerInfo = Messages.bind(Messages.classpath_containerInfo, new String[] { entryContainer.getDescription() });
                }
            }
            IJavaModelStatus status = validateLibraryEntry(path, project, containerInfo, checkSourceAttachment ? entry.getSourceAttachmentPath() : null, entryPathMsg);
            // https://bugs.eclipse.org/bugs/show_bug.cgi?id=171136, ignore class path errors from optional entries
            if (status.getCode() == IJavaModelStatusConstants.INVALID_CLASSPATH && ((ClasspathEntry) entry).isOptional())
                status = JavaModelStatus.VERIFIED_OK;
            if (!status.isOK())
                return status;
            break;
        // project entry check
        case IClasspathEntry.CPE_PROJECT:
            if (path.isAbsolute() && path.segmentCount() == 1) {
                IProject prereqProjectRsc = workspaceRoot.getProject(path.segment(0));
                IJavaProject prereqProject = JavaCore.create(prereqProjectRsc);
                try {
                    if (!prereqProjectRsc.exists() || !prereqProjectRsc.hasNature(JavaCore.NATURE_ID)) {
                        return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_unboundProject, new String[] { path.segment(0), projectName }));
                    }
                    if (!prereqProjectRsc.isOpen()) {
                        return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_closedProject, new String[] { path.segment(0) }));
                    }
                    if (!JavaCore.IGNORE.equals(project.getOption(JavaCore.CORE_INCOMPATIBLE_JDK_LEVEL, true))) {
                        long projectTargetJDK = CompilerOptions.versionToJdkLevel(project.getOption(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, true));
                        long prereqProjectTargetJDK = CompilerOptions.versionToJdkLevel(prereqProject.getOption(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, true));
                        if (prereqProjectTargetJDK > projectTargetJDK) {
                            return new JavaModelStatus(IJavaModelStatusConstants.INCOMPATIBLE_JDK_LEVEL, project, path, Messages.bind(Messages.classpath_incompatibleLibraryJDKLevel, new String[] { project.getElementName(), CompilerOptions.versionFromJdkLevel(projectTargetJDK), path.makeRelative().toString(), CompilerOptions.versionFromJdkLevel(prereqProjectTargetJDK) }));
                        }
                    }
                } catch (CoreException e) {
                    return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_unboundProject, new String[] { path.segment(0), projectName }));
                }
            } else {
                return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_illegalProjectPath, new String[] { path.toString(), projectName }));
            }
            break;
        // project source folder
        case IClasspathEntry.CPE_SOURCE:
            if (((entry.getInclusionPatterns() != null && entry.getInclusionPatterns().length > 0) || (entry.getExclusionPatterns() != null && entry.getExclusionPatterns().length > 0)) && JavaCore.DISABLED.equals(project.getOption(JavaCore.CORE_ENABLE_CLASSPATH_EXCLUSION_PATTERNS, true))) {
                return new JavaModelStatus(IJavaModelStatusConstants.DISABLED_CP_EXCLUSION_PATTERNS, project, path);
            }
            if (entry.getOutputLocation() != null && JavaCore.DISABLED.equals(project.getOption(JavaCore.CORE_ENABLE_CLASSPATH_MULTIPLE_OUTPUT_LOCATIONS, true))) {
                return new JavaModelStatus(IJavaModelStatusConstants.DISABLED_CP_MULTIPLE_OUTPUT_LOCATIONS, project, path);
            }
            if (path.isAbsolute() && !path.isEmpty()) {
                IPath projectPath = project.getProject().getFullPath();
                if (!projectPath.isPrefixOf(path) || JavaModel.getTarget(path, true) == null) {
                    return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_unboundSourceFolder, new String[] { entryPathMsg, projectName }));
                }
            } else {
                return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_illegalSourceFolderPath, new String[] { entryPathMsg, projectName }));
            }
            break;
    }
    // Validate extra attributes
    IClasspathAttribute[] extraAttributes = entry.getExtraAttributes();
    if (extraAttributes != null) {
        int length = extraAttributes.length;
        HashSet set = new HashSet(length);
        for (int i = 0; i < length; i++) {
            String attName = extraAttributes[i].getName();
            if (!set.add(attName)) {
                return new JavaModelStatus(IJavaModelStatusConstants.NAME_COLLISION, Messages.bind(Messages.classpath_duplicateEntryExtraAttribute, new String[] { attName, entryPathMsg, projectName }));
            }
        }
    }
    return JavaModelStatus.VERIFIED_OK;
}

Example 5 with IClasspathAttribute

use of org.eclipse.jdt.core.IClasspathAttribute in project che by eclipse.

the class ClasspathEntry method decodeExtraAttributes.

static IClasspathAttribute[] decodeExtraAttributes(NodeList attributes) {
    if (attributes == null)
        return NO_EXTRA_ATTRIBUTES;
    int length = attributes.getLength();
    if (length == 0)
        return NO_EXTRA_ATTRIBUTES;
    IClasspathAttribute[] result = new IClasspathAttribute[length];
    int index = 0;
    for (int i = 0; i < length; ++i) {
        Node node = attributes.item(i);
        if (node.getNodeType() == Node.ELEMENT_NODE) {
            Element attribute = (Element) node;
            String name = attribute.getAttribute(TAG_ATTRIBUTE_NAME);
            if (name == null)
                continue;
            String value = attribute.getAttribute(TAG_ATTRIBUTE_VALUE);
            if (value == null)
                continue;
            result[index++] = new ClasspathAttribute(name, value);
        }
    }
    if (index != length)
        System.arraycopy(result, 0, result = new IClasspathAttribute[index], 0, index);
    return result;
}