| package org.eclipse.epf.library.validation; |
| |
| import java.util.HashMap; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.IWorkspace; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.emf.common.util.DiagnosticChain; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.edit.ui.action.ValidateAction; |
| import org.eclipse.epf.common.utils.ExtensionHelper; |
| import org.eclipse.epf.library.LibraryPlugin; |
| import org.eclipse.epf.library.edit.validation.IValidationManager; |
| import org.eclipse.epf.uma.MethodElement; |
| import org.eclipse.epf.uma.MethodLibrary; |
| import org.eclipse.epf.uma.MethodPlugin; |
| import org.eclipse.epf.validation.LibraryEValidator; |
| |
| public class ValidationManager implements IValidationManager { |
| |
| private boolean nameCheck = false; |
| |
| private boolean circularDependancyCheck = false; |
| |
| private boolean undeclaredDependancyCheck = false; |
| |
| private IProgressMonitor progressMonitor; |
| |
| public static final String MARKER_ID = "org.eclipse.epf.library.validation"; //$NON-NLS-1$ |
| |
| private UndeclaredDependencyCheck undeclaredDependencyCheck; |
| |
| private ValidateAction emfValidateAction; |
| |
| private Map<IMarker, Object> markerInfoMap; |
| |
| private DiagnosticChain diagnostics; |
| |
| public static final String validationType = "validationType"; //$NON-NLS-1$ |
| public static final String validationType_undeclaredDependancyCheck = "undeclaredDependancyCheck"; //$NON-NLS-1$ |
| |
| public DiagnosticChain getDiagnostics() { |
| return diagnostics; |
| } |
| |
| protected ValidationManager() { |
| undeclaredDependencyCheck = newUndeclaredDependencyCheck(); |
| markerInfoMap = new HashMap<IMarker, Object>(); |
| } |
| |
| private static ValidationManager instance; |
| public static IValidationManager getInstance() { |
| if (instance == null) { |
| Object obj = ExtensionHelper.create(ValidationManager.class, null); |
| if (obj instanceof ValidationManager) { |
| instance = (ValidationManager) obj; |
| } else { |
| instance = new ValidationManager(); |
| } |
| } |
| return instance; |
| } |
| |
| public IProgressMonitor getProgressMonitor() { |
| return progressMonitor; |
| } |
| |
| public void setNameCheck(boolean b) { |
| nameCheck = b; |
| } |
| |
| public void setCircularDependancyCheck(boolean b) { |
| circularDependancyCheck = b; |
| } |
| |
| public void setUndeclaredDependancyCheck(boolean b) { |
| undeclaredDependancyCheck = b; |
| } |
| |
| public boolean isNameCheck() { |
| return nameCheck; |
| } |
| |
| public boolean isCircularDependancyCheck() { |
| return circularDependancyCheck; |
| } |
| |
| public boolean isUndeclaredDepenancyCheck() { |
| return undeclaredDependancyCheck; |
| } |
| |
| public void clearAllMarkers() { |
| if (emfValidateAction != null) { |
| emfValidateAction.updateSelection(null); |
| } |
| } |
| |
| public void validate(DiagnosticChain diagnostics, Object scope, IProgressMonitor progressMonitor) { |
| this.diagnostics = diagnostics; |
| this.progressMonitor = progressMonitor; |
| initValidationScope(scope); |
| try { |
| clearAllMarkers(); |
| validate(); |
| } finally { |
| this.progressMonitor = null; |
| |
| pluginSet = null; |
| } |
| } |
| |
| |
| private Set<MethodPlugin> pluginSet; |
| public Set<MethodPlugin> getPluginSet() { |
| return pluginSet; |
| } |
| |
| protected void initValidationScope(Object scope) { |
| pluginSet = new LinkedHashSet<MethodPlugin>(); |
| if (scope instanceof MethodLibrary) { |
| pluginSet.addAll(((MethodLibrary) scope).getMethodPlugins()); |
| } else if (scope instanceof List) { |
| for (Object obj : (List) scope) { |
| if (obj instanceof MethodPlugin) { |
| pluginSet.add((MethodPlugin) obj); |
| } |
| } |
| } |
| } |
| |
| protected void validate() { |
| clearResults(); |
| if (isUndeclaredDepenancyCheck()) { |
| undeclaredDependencyCheck.run(); |
| } |
| } |
| |
| private void clearResults() { |
| undeclaredDependencyCheck.clearResults(); |
| } |
| |
| private void appendDiagnostics(IStatus status, DiagnosticChain diagnostics) { |
| LibraryEValidator.appendDiagnostics(status, diagnostics); |
| } |
| |
| protected UndeclaredDependencyCheck newUndeclaredDependencyCheck() { |
| return new UndeclaredDependencyCheck(this); |
| } |
| |
| public IMarker createMarker(MethodElement element) { |
| return createMarker(element, MARKER_ID); |
| } |
| |
| public static IMarker createMarker(MethodElement element, String markerId) { |
| try { |
| IFile file = getFile(element); |
| IMarker marker = file.createMarker(markerId); |
| return marker; |
| |
| } catch (CoreException e) { |
| LibraryPlugin.getDefault().getLogger().logError(e); |
| } |
| return null; |
| } |
| |
| private static IFile getFile(MethodElement element) { |
| URI containerURI = element.eResource().getURI(); |
| IWorkspace workspace = ResourcesPlugin.getWorkspace(); |
| IPath path = new Path(containerURI.toFileString()); |
| IFile file = workspace.getRoot().getFileForLocation(path); |
| return file; |
| } |
| |
| public String UndeclaredDependencyCheckAddPluginFix(IMarker marker) { |
| return undeclaredDependencyCheck.addPluginFix(marker); |
| } |
| |
| public String UndeclaredDependencyCheckRemoveReferenceFix(IMarker marker) { |
| return undeclaredDependencyCheck.removeReferenceFix(marker); |
| } |
| |
| public void setEmfValidateAction(ValidateAction emfValidateAction) { |
| this.emfValidateAction = emfValidateAction; |
| } |
| |
| public void addToMarkInfoMap(IMarker marker, Object obj) { |
| markerInfoMap.put(marker, obj); |
| } |
| |
| public Object getMarkInfo(IMarker marker) { |
| return markerInfoMap.get(marker); |
| } |
| |
| public void removeFromMarkInfoMap(IMarker marker) { |
| markerInfoMap.remove(marker); |
| try { |
| if (marker.exists()) { |
| marker.delete(); |
| } |
| } catch (CoreException e) { |
| LibraryPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| |
| } |