bundles/org.eclipse.jst.ws.jaxws.dom.integration/src/org/eclipse/jst/ws/jaxws/dom/integration/navigator/WebServiceProblemsDecorator.java - webservices/webtools.webservices.jaxws - Git at Google

 /*******************************************************************************
  * Copyright (c) 2009 by SAP AG, Walldorf.
  * 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:
  *     SAP AG - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jst.ws.jaxws.dom.integration.navigator;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;

 import org.eclipse.core.resources.IMarker;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.jdt.apt.core.internal.AptPlugin;
 import org.eclipse.jdt.core.IJavaElement;
 import org.eclipse.jdt.core.IMethod;
 import org.eclipse.jdt.core.IType;
 import org.eclipse.jdt.core.ITypeParameter;
 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.ui.JavaElementImageDescriptor;
 import org.eclipse.jdt.ui.ProblemsLabelDecorator;
 import org.eclipse.jface.viewers.ILabelProviderListener;
 import org.eclipse.jface.viewers.LabelProviderChangedEvent;
 import org.eclipse.jst.ws.jaxws.dom.runtime.DomUtil;
 import org.eclipse.jst.ws.jaxws.dom.runtime.api.DomPackage;
 import org.eclipse.jst.ws.jaxws.dom.runtime.api.IServiceEndpointInterface;
 import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebMethod;
 import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebParam;
 import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebService;
 import org.eclipse.jst.ws.jaxws.dom.runtime.util.Dom2ResourceMapper;
 import org.eclipse.jst.ws.jaxws.utils.annotations.AnnotationFactory;
 import org.eclipse.jst.ws.jaxws.utils.annotations.IAnnotation;
 import org.eclipse.jst.ws.jaxws.utils.annotations.IAnnotationInspector;
 import org.eclipse.jst.ws.jaxws.utils.logging.Logger;
 import org.eclipse.ui.PlatformUI;

 @SuppressWarnings("restriction")
 public class WebServiceProblemsDecorator extends ProblemsLabelDecorator
 {
 	private static final String THIS_DECORATOR_ID = "org.eclipse.jst.ws.jaxws.dom.integration.navigator.WebServiceDecorator";

 	/**
 	 * The APT marker IDs
 	 */
 	private static final String APT_MARKER_ID = AptPlugin.APT_COMPILATION_PROBLEM_MARKER;
 	private static final String APT_NONRECONCILE_MARKER_ID = AptPlugin.APT_NONRECONCILE_COMPILATION_PROBLEM_MARKER;

 	/** Enum to represent different marker types */
 	public enum Severity {OK, ERROR, WARNING};

 	private DomUtil domUtil = DomUtil.INSTANCE;
 	private final Dom2ResourceMapper dom2ResourceMapper = Dom2ResourceMapper.INSTANCE;

 	public WebServiceProblemsDecorator()
 	{
 		addListener(new ILabelProviderListener()
 		{
 			public void labelProviderChanged(LabelProviderChangedEvent event)
 			{
 				PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable()
 				{
 					public void run()
 					{
 						PlatformUI.getWorkbench().getDecoratorManager().update(THIS_DECORATOR_ID);
 					}
 				});
 			}
 		});
 	}

 	@Override
 	protected int computeAdornmentFlags(Object obj)
 	{
 		final Severity severity = defineSeverity(obj);
 		if (severity == Severity.ERROR) {
 			return JavaElementImageDescriptor.ERROR;
 		}

 		if (severity == Severity.WARNING) {
 			return JavaElementImageDescriptor.WARNING;
 		}

 		return 0;
 	}

 	/**
 	 * Checks the object's resource for markers and defines the severity of the
 	 * problem if any.
 	 * @param obj
 	 * @return the severity calculated.
 	 */
 	protected Severity defineSeverity(final Object obj)
 	{
 		try
 		{
 			// process additional DOM objects needed for UI - IWebServiceChildList and ISEIChildList
 			if (obj instanceof IWebServiceChildList) {
 				return defineSeverityForEList(((IWebServiceChildList)obj).getWSChildList());
 			}

 			if (obj instanceof ISEIChildList) {
 				return defineSeverityForEList(((ISEIChildList)obj).getSEIChildList());
 			}

 			// do not process non DOM objects
 			if( !(obj instanceof EObject) ) {
 				return Severity.OK;
 			}

 			return defineSeverity((EObject) obj);
 		}
 		catch (CoreException e) {
 			(new Logger()).logError(e.getMessage(), e);
 		}

 		return Severity.OK;
 	}

 	protected Severity defineSeverityForEList(final List<? extends EObject> list) throws CoreException
 	{
 		Severity severity = Severity.OK;
 		for (EObject eObject : list)
 		{
 			Severity tempSeverity = defineSeverity(eObject);
 			if (tempSeverity == Severity.ERROR) {
 				return Severity.ERROR;
 			}

 			if (tempSeverity==Severity.WARNING) {
 				severity = Severity.WARNING;
 			}
 		}

 		return severity;
 	}

 	protected Severity defineSeverity(final EObject eObject) throws CoreException
 	{
 		final IResource resource = Dom2ResourceMapper.INSTANCE.findResource(eObject);
 		if (resource!=null) {
 			return defineSeverity(eObject, resource);
 		}

 		return Severity.OK;
 	}

 	protected Severity defineSeverity(final EObject eObject, final IResource resource) throws CoreException
 	{
 		if (!resource.isAccessible()) {
 			return Severity.OK;
 		}

 		final int depth = (resource.getType()==IResource.PROJECT) ? IResource.DEPTH_INFINITE : IResource.DEPTH_ZERO;
 		final Collection<IMarker> markers = findAptMarkers(resource, depth);
 		Severity severity = Severity.OK;
 		for (IMarker marker : markers)
 		{
 			if (!isRelevantFor(eObject, marker)) {
 				continue;
 			}

 			int tempSeverity = (Integer)marker.getAttribute(IMarker.SEVERITY);
 			if (tempSeverity==IMarker.SEVERITY_ERROR) {
 				return Severity.ERROR;
 			}

 			if(tempSeverity==IMarker.SEVERITY_WARNING) {
 				severity = Severity.WARNING;
 			}
 		}

 		if (severity == Severity.OK && (eObject instanceof IWebService))
 		{
 			// for bean with explicit interface we need to check the interface as well
 			// because it resides in another resource
 			final IServiceEndpointInterface sei = ((IWebService)eObject).getServiceEndpoint();
 			if (sei != null && !sei.isImplicit()) {
 				severity = defineSeverity(sei);
 			}
 		}

 		return severity;
 	}

 	/**
 	 * Defines if <code>marker</code> is relevant for <code>eObject</code>.
 	 * Only for web method and web parameter we need to define if the marker is relevant
 	 * because they are not unique in the scope of the resource. For example if there is a
 	 * marker set on the resource containing SEI, the SEI should be marked in any case
 	 * while the method only in case when the error is specifically for this method or
 	 * method parameter.
 	 * @param eObject the object to be validated
 	 * @param marker the resource marker
 	 * @return <code>true</code> in case the marker is relevant for <code>eObject</code>
 	 * @throws CoreException
 	 */
 	protected boolean isRelevantFor(final EObject eObject, final IMarker marker) throws CoreException
 	{
 		switch (eObject.eClass().getClassifierID())
 		{
 		case DomPackage.IWEB_METHOD:
 			return isRelevantForMethod((IWebMethod)eObject, marker);
 		case DomPackage.IWEB_PARAM:
 			return isRelevantForParameter((IWebParam)eObject, marker);
 		}

 		return true;
 	}

 	/**
 	 * Defines if <code>marker</code> is relevant for <code>webMethod</code>.
 	 * Checks if the marker is specifically for this method or some of it's parameters.
 	 * @param webMethod the method to be checked
 	 * @param marker the marker to be checked
 	 * @return <code>true</code> in case marker is relevant
 	 * @throws CoreException
 	 */
 	protected boolean isRelevantForMethod(final IWebMethod webMethod, final IMarker marker) throws CoreException
 	{
 		final IType type = dom2ResourceMapper.findType(webMethod);
 		final IMethod javaMethod = domUtil.findMethod(type, webMethod);
 		final IAnnotationInspector annotationInspector = AnnotationFactory.createAnnotationInspector(type);
 		boolean relevant = isMarkerRelevantFor(javaMethod, marker, annotationInspector);
 		if (!relevant)
 		{
 			for (String methodParameterName : javaMethod.getParameterNames())
 			{
 				final ITypeParameter param = javaMethod.getTypeParameter(methodParameterName);
 				relevant = relevant || isMarkerRelevantFor(param, marker, annotationInspector);
 			}
 		}

 		return relevant;
 	}

 	protected boolean isRelevantForParameter(final IWebParam webParam, final IMarker marker) throws CoreException
 	{
 		final IType type = dom2ResourceMapper.findType(webParam);
 		final ITypeParameter javaParameter = findJavaParameter(type, webParam);
 		return isMarkerRelevantFor(javaParameter, marker, AnnotationFactory.createAnnotationInspector(type));
 	}

 	/**
 	 * Finds the {@link ITypeParameter} instance which corresponds to the web parameter specified
 	 */
 	private ITypeParameter findJavaParameter(final IType type, final IWebParam webParam) throws JavaModelException
 	{
 		final IMethod javaMethod = domUtil.findMethod(type, (IWebMethod) webParam.eContainer());
 		for (String paramName : javaMethod.getParameterNames())
 		{
 			final ITypeParameter javaParam = javaMethod.getTypeParameter(paramName);
 			if (webParam.getImplementation().equals(javaParam.getElementName()))
 			{
 				return javaParam;
 			}
 		}

 		throw new IllegalStateException("Parameter " + webParam.getImplementation() + " not found");
 	}

 	private boolean isMarkerRelevantFor(final IMethod javaMethod, final IMarker marker, final IAnnotationInspector inspector) throws CoreException
 	{
 		for (IAnnotation<IMethod> ann : inspector.inspectMethod(javaMethod))
 		{
 			if (isMarkerRelevantToAnnotation(marker, ann))
 			{
 				return true;
 			}
 		}

 		return false;
 	}

 	private boolean isMarkerRelevantFor(final ITypeParameter parameter, final IMarker marker, final IAnnotationInspector inspector) throws CoreException
 	{
 		for (IAnnotation<ITypeParameter> ann : inspector.inspectParam(parameter))
 		{
 			if (isMarkerRelevantToAnnotation(marker, ann))
 			{
 				return true;
 			}
 		}

 		return false;
 	}

 	/**
 	 * Check whether the marker is relevant for the annotation specified<br>
 	 * The implementation would read all the annotations relevant for the java element and check whether the marker start/end position is between annotation start/end
 	 */
 	private boolean isMarkerRelevantToAnnotation(final IMarker marker, final IAnnotation<? extends IJavaElement> ann) throws CoreException
 	{
 		final int annStartPos = ann.getLocator().getStartPosition();
 		final int annEndPos = annStartPos + ann.getLocator().getLength() - 1;
 		return (annStartPos <= (Integer) marker.getAttribute(IMarker.CHAR_START)) && (annEndPos >= (Integer) marker.getAttribute(IMarker.CHAR_END));
 	}

 	/**
 	 * Finds all APT nonreconcile markers associated with the resource specified
 	 */
 	private Collection<IMarker> findAptMarkers(final IResource resource, final int depth) throws CoreException
 	{
 		final Collection<IMarker> result = new ArrayList<IMarker>();
 		// Search for both APT marker types. One of each IDs is used on Linux and Windows
 		for(final IMarker m : resource.findMarkers(APT_MARKER_ID, false, depth))
 		{
 			result.add(m);
 		}

 		for(final IMarker m : resource.findMarkers(APT_NONRECONCILE_MARKER_ID, false, depth))
 		{
 			result.add(m);
 		}

 		return result;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2009 by SAP AG, Walldorf.
	* 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:
	* SAP AG - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jst.ws.jaxws.dom.integration.navigator;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.List;

	import org.eclipse.core.resources.IMarker;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.jdt.apt.core.internal.AptPlugin;
	import org.eclipse.jdt.core.IJavaElement;
	import org.eclipse.jdt.core.IMethod;
	import org.eclipse.jdt.core.IType;
	import org.eclipse.jdt.core.ITypeParameter;
	import org.eclipse.jdt.core.JavaModelException;
	import org.eclipse.jdt.ui.JavaElementImageDescriptor;
	import org.eclipse.jdt.ui.ProblemsLabelDecorator;
	import org.eclipse.jface.viewers.ILabelProviderListener;
	import org.eclipse.jface.viewers.LabelProviderChangedEvent;
	import org.eclipse.jst.ws.jaxws.dom.runtime.DomUtil;
	import org.eclipse.jst.ws.jaxws.dom.runtime.api.DomPackage;
	import org.eclipse.jst.ws.jaxws.dom.runtime.api.IServiceEndpointInterface;
	import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebMethod;
	import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebParam;
	import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebService;
	import org.eclipse.jst.ws.jaxws.dom.runtime.util.Dom2ResourceMapper;
	import org.eclipse.jst.ws.jaxws.utils.annotations.AnnotationFactory;
	import org.eclipse.jst.ws.jaxws.utils.annotations.IAnnotation;
	import org.eclipse.jst.ws.jaxws.utils.annotations.IAnnotationInspector;
	import org.eclipse.jst.ws.jaxws.utils.logging.Logger;
	import org.eclipse.ui.PlatformUI;

	@SuppressWarnings("restriction")
	public class WebServiceProblemsDecorator extends ProblemsLabelDecorator
	{
	private static final String THIS_DECORATOR_ID = "org.eclipse.jst.ws.jaxws.dom.integration.navigator.WebServiceDecorator";

	/**
	* The APT marker IDs
	*/
	private static final String APT_MARKER_ID = AptPlugin.APT_COMPILATION_PROBLEM_MARKER;
	private static final String APT_NONRECONCILE_MARKER_ID = AptPlugin.APT_NONRECONCILE_COMPILATION_PROBLEM_MARKER;

	/** Enum to represent different marker types */
	public enum Severity {OK, ERROR, WARNING};

	private DomUtil domUtil = DomUtil.INSTANCE;
	private final Dom2ResourceMapper dom2ResourceMapper = Dom2ResourceMapper.INSTANCE;

	public WebServiceProblemsDecorator()
	{
	addListener(new ILabelProviderListener()
	{
	public void labelProviderChanged(LabelProviderChangedEvent event)
	{
	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable()
	{
	public void run()
	{
	PlatformUI.getWorkbench().getDecoratorManager().update(THIS_DECORATOR_ID);
	}
	});
	}
	});
	}

	@Override
	protected int computeAdornmentFlags(Object obj)
	{
	final Severity severity = defineSeverity(obj);
	if (severity == Severity.ERROR) {
	return JavaElementImageDescriptor.ERROR;
	}

	if (severity == Severity.WARNING) {
	return JavaElementImageDescriptor.WARNING;
	}

	return 0;
	}

	/**
	* Checks the object's resource for markers and defines the severity of the
	* problem if any.
	* @param obj
	* @return the severity calculated.
	*/
	protected Severity defineSeverity(final Object obj)
	{
	try
	{
	// process additional DOM objects needed for UI - IWebServiceChildList and ISEIChildList
	if (obj instanceof IWebServiceChildList) {
	return defineSeverityForEList(((IWebServiceChildList)obj).getWSChildList());
	}

	if (obj instanceof ISEIChildList) {
	return defineSeverityForEList(((ISEIChildList)obj).getSEIChildList());
	}

	// do not process non DOM objects
	if( !(obj instanceof EObject) ) {
	return Severity.OK;
	}

	return defineSeverity((EObject) obj);
	}
	catch (CoreException e) {
	(new Logger()).logError(e.getMessage(), e);
	}

	return Severity.OK;
	}

	protected Severity defineSeverityForEList(final List<? extends EObject> list) throws CoreException
	{
	Severity severity = Severity.OK;
	for (EObject eObject : list)
	{
	Severity tempSeverity = defineSeverity(eObject);
	if (tempSeverity == Severity.ERROR) {
	return Severity.ERROR;
	}

	if (tempSeverity==Severity.WARNING) {
	severity = Severity.WARNING;
	}
	}

	return severity;
	}

	protected Severity defineSeverity(final EObject eObject) throws CoreException
	{
	final IResource resource = Dom2ResourceMapper.INSTANCE.findResource(eObject);
	if (resource!=null) {
	return defineSeverity(eObject, resource);
	}

	return Severity.OK;
	}

	protected Severity defineSeverity(final EObject eObject, final IResource resource) throws CoreException
	{
	if (!resource.isAccessible()) {
	return Severity.OK;
	}

	final int depth = (resource.getType()==IResource.PROJECT) ? IResource.DEPTH_INFINITE : IResource.DEPTH_ZERO;
	final Collection<IMarker> markers = findAptMarkers(resource, depth);
	Severity severity = Severity.OK;
	for (IMarker marker : markers)
	{
	if (!isRelevantFor(eObject, marker)) {
	continue;
	}

	int tempSeverity = (Integer)marker.getAttribute(IMarker.SEVERITY);
	if (tempSeverity==IMarker.SEVERITY_ERROR) {
	return Severity.ERROR;
	}

	if(tempSeverity==IMarker.SEVERITY_WARNING) {
	severity = Severity.WARNING;
	}
	}

	if (severity == Severity.OK && (eObject instanceof IWebService))
	{
	// for bean with explicit interface we need to check the interface as well
	// because it resides in another resource
	final IServiceEndpointInterface sei = ((IWebService)eObject).getServiceEndpoint();
	if (sei != null && !sei.isImplicit()) {
	severity = defineSeverity(sei);
	}
	}

	return severity;
	}

	/**
	* Defines if <code>marker</code> is relevant for <code>eObject</code>.
	* Only for web method and web parameter we need to define if the marker is relevant
	* because they are not unique in the scope of the resource. For example if there is a
	* marker set on the resource containing SEI, the SEI should be marked in any case
	* while the method only in case when the error is specifically for this method or
	* method parameter.
	* @param eObject the object to be validated
	* @param marker the resource marker
	* @return <code>true</code> in case the marker is relevant for <code>eObject</code>
	* @throws CoreException
	*/
	protected boolean isRelevantFor(final EObject eObject, final IMarker marker) throws CoreException
	{
	switch (eObject.eClass().getClassifierID())
	{
	case DomPackage.IWEB_METHOD:
	return isRelevantForMethod((IWebMethod)eObject, marker);
	case DomPackage.IWEB_PARAM:
	return isRelevantForParameter((IWebParam)eObject, marker);
	}

	return true;
	}

	/**
	* Defines if <code>marker</code> is relevant for <code>webMethod</code>.
	* Checks if the marker is specifically for this method or some of it's parameters.
	* @param webMethod the method to be checked
	* @param marker the marker to be checked
	* @return <code>true</code> in case marker is relevant
	* @throws CoreException
	*/
	protected boolean isRelevantForMethod(final IWebMethod webMethod, final IMarker marker) throws CoreException
	{
	final IType type = dom2ResourceMapper.findType(webMethod);
	final IMethod javaMethod = domUtil.findMethod(type, webMethod);
	final IAnnotationInspector annotationInspector = AnnotationFactory.createAnnotationInspector(type);
	boolean relevant = isMarkerRelevantFor(javaMethod, marker, annotationInspector);
	if (!relevant)
	{
	for (String methodParameterName : javaMethod.getParameterNames())
	{
	final ITypeParameter param = javaMethod.getTypeParameter(methodParameterName);
	relevant = relevant \|\| isMarkerRelevantFor(param, marker, annotationInspector);
	}
	}

	return relevant;
	}

	protected boolean isRelevantForParameter(final IWebParam webParam, final IMarker marker) throws CoreException
	{
	final IType type = dom2ResourceMapper.findType(webParam);
	final ITypeParameter javaParameter = findJavaParameter(type, webParam);
	return isMarkerRelevantFor(javaParameter, marker, AnnotationFactory.createAnnotationInspector(type));
	}

	/**
	* Finds the {@link ITypeParameter} instance which corresponds to the web parameter specified
	*/
	private ITypeParameter findJavaParameter(final IType type, final IWebParam webParam) throws JavaModelException
	{
	final IMethod javaMethod = domUtil.findMethod(type, (IWebMethod) webParam.eContainer());
	for (String paramName : javaMethod.getParameterNames())
	{
	final ITypeParameter javaParam = javaMethod.getTypeParameter(paramName);
	if (webParam.getImplementation().equals(javaParam.getElementName()))
	{
	return javaParam;
	}
	}

	throw new IllegalStateException("Parameter " + webParam.getImplementation() + " not found");
	}

	private boolean isMarkerRelevantFor(final IMethod javaMethod, final IMarker marker, final IAnnotationInspector inspector) throws CoreException
	{
	for (IAnnotation<IMethod> ann : inspector.inspectMethod(javaMethod))
	{
	if (isMarkerRelevantToAnnotation(marker, ann))
	{
	return true;
	}
	}

	return false;
	}

	private boolean isMarkerRelevantFor(final ITypeParameter parameter, final IMarker marker, final IAnnotationInspector inspector) throws CoreException
	{
	for (IAnnotation<ITypeParameter> ann : inspector.inspectParam(parameter))
	{
	if (isMarkerRelevantToAnnotation(marker, ann))
	{
	return true;
	}
	}

	return false;
	}

	/**
	* Check whether the marker is relevant for the annotation specified<br>
	* The implementation would read all the annotations relevant for the java element and check whether the marker start/end position is between annotation start/end
	*/
	private boolean isMarkerRelevantToAnnotation(final IMarker marker, final IAnnotation<? extends IJavaElement> ann) throws CoreException
	{
	final int annStartPos = ann.getLocator().getStartPosition();
	final int annEndPos = annStartPos + ann.getLocator().getLength() - 1;
	return (annStartPos <= (Integer) marker.getAttribute(IMarker.CHAR_START)) && (annEndPos >= (Integer) marker.getAttribute(IMarker.CHAR_END));
	}

	/**
	* Finds all APT nonreconcile markers associated with the resource specified
	*/
	private Collection<IMarker> findAptMarkers(final IResource resource, final int depth) throws CoreException
	{
	final Collection<IMarker> result = new ArrayList<IMarker>();
	// Search for both APT marker types. One of each IDs is used on Linux and Windows
	for(final IMarker m : resource.findMarkers(APT_MARKER_ID, false, depth))
	{
	result.add(m);
	}

	for(final IMarker m : resource.findMarkers(APT_NONRECONCILE_MARKER_ID, false, depth))
	{
	result.add(m);
	}

	return result;
	}
	}