| /******************************************************************************* |
| * Copyright (c) 2016 ALL4TEC & CEA LIST. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * ALL4TEC & CEA LIST - initial API and implementation |
| ******************************************************************************/ |
| package org.polarsys.esf.core.common.adapter; |
| |
| import java.util.HashSet; |
| import java.util.LinkedHashMap; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.common.util.BasicDiagnostic; |
| import org.eclipse.emf.common.util.Diagnostic; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.util.EContentAdapter; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.polarsys.esf.core.common.CommonActivator; |
| import org.polarsys.esf.core.common.listener.IProblemIndicationListener; |
| |
| |
| /** |
| * Content adapter used to analyse resources content and build the problem indication. |
| * It maintains a set of listeners to warn when a new diagnostic is built. |
| * |
| * NB : It extends {@link EContentAdapter} to listen to all the changes on a resource and its content. |
| * |
| * @author $Author: jdumont $ |
| * @version $Revision: 83 $ |
| */ |
| public class ProblemIndicationAdapter extends EContentAdapter { |
| |
| /** Map to store the diagnostic associated with a resource. */ |
| private Map<Resource, Diagnostic> mResourceToDiagnosticMap = new LinkedHashMap<Resource, Diagnostic>(); |
| |
| /** Set of listening objects, waiting for the diagnostics results. */ |
| private Set<IProblemIndicationListener> mListenersSet = new HashSet<IProblemIndicationListener>(); |
| |
| |
| /** |
| * Default constructor. |
| */ |
| public ProblemIndicationAdapter() { |
| // Nothing to do |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| public void notifyChanged(final Notification pNotification) { |
| |
| // Check if the notification come from a Resource |
| if (pNotification.getNotifier() instanceof Resource) { |
| // Switch according to the properties modified, the resource can |
| // be loading, or errors/warning can be identified |
| switch (pNotification.getFeatureID(Resource.class)) { |
| case Resource.RESOURCE__IS_LOADED: |
| case Resource.RESOURCE__ERRORS: |
| case Resource.RESOURCE__WARNINGS: |
| // Get the resource underlying the notification |
| Resource vResource = (Resource) pNotification.getNotifier(); |
| |
| // Analyse the resource and get its diagnostic |
| Diagnostic vDiagnostic = analyzeResourceProblems(vResource, null); |
| |
| // If any error found, store it in the diagnostic map |
| // otherwise clean the potential existing diagnostic associated |
| // to this resource |
| if (vDiagnostic.getSeverity() != Diagnostic.OK) { |
| mResourceToDiagnosticMap.put(vResource, vDiagnostic); |
| } else { |
| mResourceToDiagnosticMap.remove(vResource); |
| } |
| |
| // Warn all the listeners that the diagnostics has changed |
| fireProblemIndication(); |
| |
| break; |
| |
| default: |
| // By default, nothing to do |
| break; |
| } |
| |
| } else { |
| // Call the parent method for all the others type of notifiers |
| super.notifyChanged(pNotification); |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| protected void setTarget(final Resource pTargetResource) { |
| // Set the resource to listen |
| basicSetTarget(pTargetResource); |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| protected void unsetTarget(final Resource pTargetResource) { |
| // Unset the resource to listen |
| basicUnsetTarget(pTargetResource); |
| |
| // Clean all the diagnostics linked to the previously listened resource |
| mResourceToDiagnosticMap.remove(pTargetResource); |
| |
| // Warn all the listeners that the diagnostics has changed |
| fireProblemIndication(); |
| } |
| |
| /** |
| * Returns a diagnostic describing the errors and warnings listed in the resource |
| * and the specified exception (if any). |
| * |
| * @param pResource The resource to analyse |
| * @param pException The potential exception thrown during the resource creation or load. May be null |
| * @return The resulting diagnostic |
| */ |
| private Diagnostic analyzeResourceProblems(final Resource pResource, final Exception pException) { |
| // Create the default diagnostic to return |
| Diagnostic vDiagnostic = Diagnostic.OK_INSTANCE; |
| |
| if (pResource == null) { |
| // The resource is null, create a basic error diagnostic |
| vDiagnostic = new BasicDiagnostic( |
| Diagnostic.ERROR, |
| CommonActivator.getPlugin().getSymbolicName(), |
| 0, |
| CommonActivator.getMessages().getString( |
| "ProblemIndicationAdapter.diagnostics.error.null"), //$NON-NLS-1$ |
| new Object[] {pException }); |
| |
| } else if (!pResource.getErrors().isEmpty() || !pResource.getWarnings().isEmpty()) { |
| // Build the diagnostic data with the given exception, or the resource directly |
| Object[] vDataArray = null; |
| if (pException == null) { |
| vDataArray = new Object[] {pException }; |
| } else { |
| vDataArray = new Object[] {pResource }; |
| } |
| |
| // The resource is invalid, create a basic error diagnostic |
| vDiagnostic = new BasicDiagnostic( |
| Diagnostic.ERROR, |
| CommonActivator.getPlugin().getSymbolicName(), |
| 0, |
| CommonActivator.getMessages().getString( |
| "ProblemIndicationAdapter.diagnostics.error.creation", //$NON-NLS-1$ |
| new Object[] {pResource.getURI()}), |
| vDataArray); |
| |
| // Add the details in the root diagnostic |
| ((BasicDiagnostic) vDiagnostic).merge(EcoreUtil.computeDiagnostic(pResource, true)); |
| |
| } else if (pException != null) { |
| // An exception is given, create a basic diagnostic for it |
| vDiagnostic = new BasicDiagnostic( |
| Diagnostic.ERROR, |
| CommonActivator.getPlugin().getSymbolicName(), |
| 0, |
| CommonActivator.getMessages().getString( |
| "ProblemIndicationAdapter.diagnostics.error.exception", //$NON-NLS-1$ |
| new Object[] {pResource.getURI()}), |
| new Object[] {pException }); |
| } |
| |
| return vDiagnostic; |
| } |
| |
| |
| /** |
| * Analyse a resource, given in parameter, to identify its potential problems. |
| * All the errors or warnings found are saved to be able to build a global diagnostic |
| * and transfer it to the listeners at the end of this method execution. |
| * |
| * An exception can be given, to be integrated to the diagnostics, for example if it has |
| * been thrown during the resource load or save. |
| * |
| * @param pResource The resource to analyse |
| * @param pException The potential exception thrown during the resource creation or load. May be null |
| */ |
| public void analyzeResource(final Resource pResource, final Exception pException) { |
| |
| boolean vDiagnosticsChanged = false; |
| |
| // If the resource is not already registered with a problem, |
| // do its analyse, potentially with the given exception, and |
| // remember of the resulting diagnostic |
| if (!mResourceToDiagnosticMap.containsKey(pResource)) { |
| |
| // Analyse the resource and get the resulting diagnostic |
| Diagnostic vDiagnostic = analyzeResourceProblems(pResource, pException); |
| |
| // If an error is identified, register it in the map of diagnostic, for this resource |
| if (vDiagnostic.getSeverity() != Diagnostic.OK) { |
| mResourceToDiagnosticMap.put(pResource, vDiagnostic); |
| |
| // Remember that the diagnostics have changed |
| vDiagnosticsChanged = true; |
| } |
| } |
| |
| // Once the analysis is done, warn the listener if the diagnostics changed |
| if (vDiagnosticsChanged) { |
| fireProblemIndication(); |
| } |
| } |
| |
| /** |
| * Return a root diagnostic containing as children all the diagnostics |
| * for each analysed resource. |
| * |
| * The diagnostics are taken from the current state, resulting of the analysis |
| * previously done by this adapter. |
| * |
| * @return The current diagnostic |
| */ |
| public Diagnostic getDiagnostic() { |
| // Create the root diagnostic to enrich with the identified diagnostics |
| BasicDiagnostic vRootDiagnostic = new BasicDiagnostic( |
| Diagnostic.OK, |
| CommonActivator.getPlugin().getSymbolicName(), |
| 0, |
| null, |
| null); |
| |
| // Loop on the diagnostics identified, and add them to the root |
| // if they correspond to an error or a warning |
| for (Diagnostic vChildDiagnostic : mResourceToDiagnosticMap.values()) { |
| if (vChildDiagnostic.getSeverity() != Diagnostic.OK) { |
| vRootDiagnostic.add(vChildDiagnostic); |
| } |
| } |
| |
| return vRootDiagnostic; |
| } |
| |
| /** |
| * Add a listener for the diagnostics results. |
| * This has no effect if an identical listener is already registered. |
| * |
| * @param pListener The new listener to add |
| */ |
| public void addProblemIndicationListener(final IProblemIndicationListener pListener) { |
| mListenersSet.add(pListener); |
| } |
| |
| /** |
| * Remove the given listener. |
| * This has no affect if the listener is not registered. |
| * |
| * @param pListener The listener to remove |
| */ |
| public void removeProblemIndicationListener(final IProblemIndicationListener pListener) { |
| mListenersSet.remove(pListener); |
| } |
| |
| /** |
| * Warn all the listeners that a new diagnostic has been built. |
| */ |
| private void fireProblemIndication() { |
| // Get the new root diagnostic |
| Diagnostic vDiagnostic = getDiagnostic(); |
| |
| // Warn all the listeners |
| for (IProblemIndicationListener vListener : mListenersSet) { |
| vListener.updateProblemIndication(vDiagnostic); |
| } |
| |
| } |
| |
| } |
