| /******************************************************************************* |
| * Copyright (c) 2010 SAP AG. |
| * 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: |
| * Emil Simeonov - initial API and implementation. |
| * Dimitar Donchev - initial API and implementation. |
| * Dimitar Tenev - initial API and implementation. |
| * Nevena Manova - initial API and implementation. |
| * Georgi Konstantinov - initial API and implementation. |
| *******************************************************************************/ |
| package org.eclipse.wst.sse.sieditor.model.validation; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.core.runtime.ILog; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.MultiStatus; |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.resource.ResourceSet; |
| import org.eclipse.emf.ecore.util.EContentAdapter; |
| import org.eclipse.emf.transaction.TransactionalEditingDomain.Lifecycle; |
| import org.eclipse.emf.transaction.util.Adaptable; |
| import org.eclipse.emf.validation.model.EvaluationMode; |
| import org.eclipse.emf.validation.model.IConstraintStatus; |
| import org.eclipse.emf.validation.service.IBatchValidator; |
| import org.eclipse.emf.validation.service.IConstraintFilter; |
| import org.eclipse.emf.validation.service.ILiveValidator; |
| import org.eclipse.emf.validation.service.ModelValidationService; |
| import org.eclipse.emf.workspace.WorkspaceEditingDomainFactory; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.wst.wsdl.Definition; |
| import org.eclipse.wst.wsdl.util.WSDLResourceImpl; |
| import org.eclipse.xsd.XSDConcreteComponent; |
| import org.eclipse.xsd.XSDDiagnostic; |
| import org.eclipse.xsd.XSDSchema; |
| import org.eclipse.xsd.util.XSDResourceImpl; |
| |
| import org.eclipse.wst.sse.sieditor.core.common.IDisposable; |
| import org.eclipse.wst.sse.sieditor.core.common.Logger; |
| import org.eclipse.wst.sse.sieditor.model.Activator; |
| import org.eclipse.wst.sse.sieditor.model.api.IModelObject; |
| import org.eclipse.wst.sse.sieditor.model.api.IModelRoot; |
| import org.eclipse.wst.sse.sieditor.model.validation.impl.ValidationEvent; |
| import org.eclipse.wst.sse.sieditor.model.validation.impl.ValidationStatus; |
| import org.eclipse.wst.sse.sieditor.model.validation.impl.ValidationStatusRegistry; |
| import org.eclipse.wst.sse.sieditor.model.validation.impl.XSDDiagnosticValidationStatus; |
| |
| public class ValidationService extends EContentAdapter implements IValidationService, IDisposable { |
| |
| public static final String OPTION_BATCH_VALIDTION = "batch_validation"; //$NON-NLS-1$ |
| private final ValidationStatusRegistry registry; |
| private final List<IModelAdapter> adapters; |
| private final List<IValidationListener> listeners; |
| |
| protected ILiveValidator liveValidator; |
| protected IBatchValidator batchValidator; |
| |
| private EditingDomainListener editingDomainListener; |
| |
| private ResourceSet resourceSet; |
| |
| private static final ILog logger = Activator.getDefault().getLog(); |
| |
| private final boolean logEnabled; |
| |
| public ValidationService(final ResourceSet resourceSet, final IModelRoot modelRoot) { |
| super(); |
| |
| registry = new ValidationStatusRegistry(); |
| adapters = new ArrayList<IModelAdapter>(); |
| listeners = new ArrayList<IValidationListener>(); |
| |
| liveValidator = ModelValidationService.getInstance().newValidator(EvaluationMode.LIVE); |
| liveValidator.setReportSuccesses(true); |
| |
| batchValidator = ModelValidationService.getInstance().newValidator(EvaluationMode.BATCH); |
| batchValidator.setReportSuccesses(true); |
| batchValidator.setIncludeLiveConstraints(true); |
| |
| update(resourceSet, modelRoot); |
| |
| logEnabled = System.getProperty("validationLogging") != null; //$NON-NLS-1$ |
| } |
| |
| public void update(final ResourceSet resourceSet, final IModelRoot modelRoot) { |
| detachFromCurrentResourceSet(); |
| final Adaptable editingDomainAdaptable = (Adaptable) WorkspaceEditingDomainFactory.INSTANCE.getEditingDomain(resourceSet); |
| final Lifecycle lifecycle = editingDomainAdaptable.getAdapter(Lifecycle.class); |
| |
| editingDomainListener = new EditingDomainListener(this); |
| lifecycle.addTransactionalEditingDomainListener(editingDomainListener); |
| |
| resourceSet.eAdapters().add(this); |
| this.resourceSet = resourceSet; |
| } |
| |
| private void detachFromCurrentResourceSet() { |
| if (resourceSet == null) { |
| return; |
| } |
| final Adaptable editingDomainAdaptable = (Adaptable) WorkspaceEditingDomainFactory.INSTANCE.getEditingDomain(resourceSet); |
| |
| if (editingDomainAdaptable != null) { |
| final Lifecycle lifecycle = editingDomainAdaptable.getAdapter(Lifecycle.class); |
| |
| lifecycle.removeTransactionalEditingDomainListener(editingDomainListener); |
| resourceSet.eAdapters().remove(this); |
| } |
| } |
| |
| @Override |
| public Set<IModelObject> validate(final Object source) { |
| |
| final EObject obj; |
| if (source instanceof EObject) { |
| obj = (EObject) source; |
| } else { |
| obj = adaptToEMFObject(source); |
| } |
| |
| if (obj == null) { |
| return Collections.emptySet(); |
| } |
| |
| try { |
| registry.clearSchemaOrDefinition(obj); |
| final IStatus result = batchValidator.validate(obj); |
| return processValidationResults(result, EvaluationMode.BATCH); |
| } catch (final Exception e) { |
| Logger.log(Activator.PLUGIN_ID, IStatus.WARNING, "Can not validate: " + obj.toString(), e); //$NON-NLS-1$ |
| } |
| return Collections.emptySet(); |
| } |
| |
| public Set<IModelObject> validateAll(final Collection<?> sources) { |
| |
| final Set<IStatus> statuses = new HashSet<IStatus>(); |
| |
| for (final Object source : sources) { |
| final EObject obj; |
| if (source instanceof EObject) { |
| obj = (EObject) source; |
| } else { |
| obj = adaptToEMFObject(source); |
| } |
| |
| if (obj == null) { |
| return Collections.emptySet(); |
| } |
| try { |
| registry.clearSchemaOrDefinition(obj); |
| statuses.add(batchValidator.validate(obj)); |
| } catch (final Exception e) { |
| Logger.log(Activator.PLUGIN_ID, IStatus.WARNING, "Can not validate: " + obj.toString(), e); //$NON-NLS-1$ |
| } |
| } |
| |
| return processValidationResults(new MultiStatus(Activator.PLUGIN_ID, IStatus.INFO, statuses.toArray(new IStatus[statuses |
| .size()]), "This is a multistatus. Check children", null), EvaluationMode.BATCH); //$NON-NLS-1$ |
| |
| } |
| |
| protected boolean validateDescription(final EObject eObject) { |
| final Resource resource = eObject.eResource(); |
| if (resource != null && isWSDLResource(resource)) { |
| validate(getDefinitionFromResource(resource)); |
| return true; |
| } |
| return false; |
| } |
| |
| protected boolean isWSDLResource(final Resource resource) { |
| return resource instanceof WSDLResourceImpl; |
| } |
| |
| protected Definition getDefinitionFromResource(final Resource resource) { |
| return ((WSDLResourceImpl) resource).getDefinition(); |
| } |
| |
| public void liveValidate(final Collection<Notification> notifications) { |
| final Set<XSDSchema> schemas = new HashSet<XSDSchema>(); |
| boolean descriptionValidated = false; |
| boolean descriptionNeedsValidation = false; |
| |
| for (final Notification notification : notifications) { |
| |
| Object notifier = notification.getNotifier(); |
| if (notifier instanceof WSDLResourceImpl) { |
| |
| notifier = ((WSDLResourceImpl) notifier).getDefinition(); |
| } else if (notifier instanceof XSDResourceImpl) { |
| notifier = ((XSDResourceImpl) notifier).getSchema(); |
| } |
| if (notifier instanceof XSDConcreteComponent) { |
| |
| final XSDSchema schema = ((XSDConcreteComponent) notifier).getSchema(); |
| |
| if (schemas.contains(schema) || schema == null) { |
| continue; |
| } |
| if (schema != null) { |
| registry.clearSchemaOrDefinition(schema); |
| schemas.add(schema); |
| } |
| liveValidate(notification); |
| descriptionNeedsValidation = true; |
| |
| } else if (!(notifier instanceof EObject)) { |
| continue; |
| } else { |
| descriptionNeedsValidation = true; |
| } |
| |
| if (!descriptionValidated && descriptionNeedsValidation) { |
| descriptionValidated = validateDescription((EObject) notifier); |
| } |
| } |
| } |
| |
| protected void liveValidate(final Notification notification) { |
| processValidationResults(liveValidator.validate(notification), EvaluationMode.LIVE); |
| } |
| |
| @Override |
| public void notifyChanged(final Notification notification) { |
| super.notifyChanged(notification); |
| } |
| |
| public void addConstraintFilter(final IConstraintFilter constraintFilter) { |
| liveValidator.addConstraintFilter(constraintFilter); |
| batchValidator.addConstraintFilter(constraintFilter); |
| } |
| |
| public void addModelAdapter(final IModelAdapter modelAdapter) { |
| if (!adapters.contains(modelAdapter)) { |
| adapters.add(modelAdapter); |
| } |
| } |
| |
| public void removeConstraintFilter(final IConstraintFilter constraintFilter) { |
| liveValidator.removeConstraintFilter(constraintFilter); |
| batchValidator.removeConstraintFilter(constraintFilter); |
| } |
| |
| public void removeModelAdapter(final IModelAdapter modelAdapter) { |
| adapters.remove(modelAdapter); |
| } |
| |
| public void addValidationListener(final IValidationListener listener) { |
| if (!listeners.contains(listener)) { |
| listeners.add(listener); |
| } |
| } |
| |
| public List<IValidationListener> getValidationListeners() { |
| return Collections.unmodifiableList(listeners); |
| } |
| |
| public Collection<IModelAdapter> getModelAdapters() { |
| return adapters; |
| } |
| |
| public void removeValidationListener(final IValidationListener listener) { |
| listeners.remove(listener); |
| } |
| |
| public IValidationStatusProvider getValidationStatusProvider() { |
| return registry; |
| } |
| |
| private Set<IModelObject> processValidationResults(final IStatus status, final EvaluationMode<?> mode) { |
| final List<IValidationStatus> validationStatusList = new ArrayList<IValidationStatus>(); |
| processStatus(status, validationStatusList); |
| |
| if (validationStatusList != null && !validationStatusList.isEmpty()) { |
| final Set<IModelObject> updatedModelObjects = registry.add(validationStatusList); |
| |
| notifyListeners(updatedModelObjects, mode); |
| return updatedModelObjects; |
| } |
| return Collections.emptySet(); |
| } |
| |
| private void processStatus(final IStatus status, final List<IValidationStatus> validationStatusList) { |
| if (status.isMultiStatus()) { |
| final IStatus[] children = status.getChildren(); |
| for (final IStatus subStatus : children) { |
| if (subStatus.isMultiStatus()) { |
| processStatus(subStatus, validationStatusList); |
| continue; |
| } |
| processSingleValidationStatus(subStatus, validationStatusList); |
| } |
| } else { |
| processSingleValidationStatus(status, validationStatusList); |
| } |
| } |
| |
| private void processSingleValidationStatus(final IStatus status, final List<IValidationStatus> validationStatusList) { |
| if (logEnabled && !status.isOK()) { |
| logger.log(status); |
| } |
| if (!(status instanceof IConstraintStatus)) { |
| return; |
| } |
| |
| final EObject constraintStatusTarget = ((IConstraintStatus)status).getTarget(); |
| final Collection<IModelObject> modelObjects = adaptToModelObject(constraintStatusTarget); |
| |
| for (final IModelObject modelObject : modelObjects) { |
| if (constraintStatusTarget instanceof XSDDiagnostic && !status.isOK()) { |
| validationStatusList.add(new XSDDiagnosticValidationStatus((IConstraintStatus)status, modelObject)); |
| } else { |
| validationStatusList.add(new ValidationStatus((IConstraintStatus)status, modelObject)); |
| } |
| } |
| } |
| |
| private EObject adaptToEMFObject(final Object source) { |
| for (final IModelAdapter modelAdapter : adapters) { |
| final EObject eObject = modelAdapter.adapatToEMF(source); |
| if (eObject != null) { |
| return eObject; |
| } |
| } |
| return null; |
| } |
| |
| public Set<IModelObject> adaptToModelObject(final EObject source) { |
| final Set<IModelObject> modelObjects = new HashSet<IModelObject>(); |
| |
| for (final IModelAdapter modelAdapter : adapters) { |
| final IModelObject modelObject = (IModelObject) modelAdapter.adaptToModelObject(source); |
| if (modelObject != null) { |
| modelObjects.add(modelObject); |
| } |
| } |
| return modelObjects; |
| } |
| |
| private void notifyListeners(final Set<IModelObject> modelObjects, final EvaluationMode<?> mode) { |
| |
| final int intMode = (mode == EvaluationMode.LIVE) ? IValidationEvent.LIVE_MODE : IValidationEvent.BATCH_MODE; |
| |
| for (final IValidationListener listener : listeners) { |
| final Set<Object> supportedObjects = new HashSet<Object>(); |
| for (final Object modelObject : modelObjects) { |
| if (listener.isSupportedModelObject(modelObject)) { |
| supportedObjects.add(modelObject); |
| } |
| } |
| final ValidationEvent event = new ValidationEvent(registry, supportedObjects, intMode); |
| if (Display.getCurrent() != null) { |
| listener.validationPerformed(event); |
| } else { |
| Display.getDefault().asyncExec(new Runnable() { |
| |
| public void run() { |
| |
| listener.validationPerformed(event); |
| |
| } |
| }); |
| } |
| } |
| } |
| |
| @Override |
| public void doDispose() { |
| detachFromCurrentResourceSet(); |
| |
| } |
| |
| } |
