archive/org.eclipse.ocl.examples.editor.ocl.ui.ecore/src/org/eclipse/ocl/examples/editor/ocl/ui/ecore/OCLInEcoreSynchronizer.java - ocl/org.eclipse.ocl - Git at Google

 /**
  * <copyright>
  *
  * Copyright (c) 2010 Eclipse Modeling Project and others.
  * 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:
  *   E.D.Willink - Initial API and implementation
  *
  * </copyright>
  *
  * $Id: OCLInEcoreSynchronizer.java,v 1.4 2010/03/22 01:23:49 ewillink Exp $
  */
 package org.eclipse.ocl.examples.editor.ocl.ui.ecore;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;

 import lpg.runtime.IToken;

 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.Notifier;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.common.util.EMap;
 import org.eclipse.emf.ecore.EAnnotation;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EClassifier;
 import org.eclipse.emf.ecore.EEnumLiteral;
 import org.eclipse.emf.ecore.EModelElement;
 import org.eclipse.emf.ecore.ENamedElement;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EOperation;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.EParameter;
 import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.emf.ecore.ETypedElement;
 import org.eclipse.emf.ecore.EcoreFactory;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.ecore.resource.ResourceSet;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.ocl.cst.CSTNode;
 import org.eclipse.ocl.ecore.CallOperationAction;
 import org.eclipse.ocl.ecore.Constraint;
 import org.eclipse.ocl.ecore.EcoreEnvironmentFactory;
 import org.eclipse.ocl.ecore.ExpressionInOCL;
 import org.eclipse.ocl.ecore.SendSignalAction;
 import org.eclipse.ocl.examples.common.utils.ClassUtils;
 import org.eclipse.ocl.examples.common.utils.EcoreUtils;
 import org.eclipse.ocl.examples.common.utils.StringUtils;
 import org.eclipse.ocl.examples.common.utils.TracingAdapter;
 import org.eclipse.ocl.lpg.BasicEnvironment;
 import org.eclipse.ocl.lpg.BasicEnvironment2;
 import org.eclipse.ocl.utilities.UMLReflection;

 public abstract class OCLInEcoreSynchronizer extends TracingAdapter
 {
 	public static String getSourceText(BasicEnvironment environment, Object astNode) {
 		CSTNode astMapping = environment.getASTMapping(astNode);
 		IToken startToken = astMapping.getStartToken();
 		IToken prevToken = startToken.getIPrsStream().getIToken(startToken.getTokenIndex()-1);
 		IToken endToken = astMapping.getEndToken();
 		IToken[] followingAdjuncts = endToken.getFollowingAdjuncts();
 		if ((followingAdjuncts != null) && (followingAdjuncts.length > 0)) {
 			endToken = followingAdjuncts[followingAdjuncts.length-1];
 		}
 		return startToken.getILexStream().toString(prevToken.getEndOffset()+1, endToken.getEndOffset());
 	}

 	private static final String ECORE_URI = org.eclipse.emf.ecore.EcorePackage.eNS_URI;
 	private static final String OCL_URI = ECORE_URI + "/OCL";
 	private static final String CONSTRAINTS_KEY = "constraints";
 	private static final String BODY_KEY = "body";
 	private static final String DERIVATION_KEY = "derivation";
 	private static final String INITIAL_KEY = "initial";
 	private static final String POSTCONDITION_KEY = "postcondition";
 	private static final String PRECONDITION_KEY = "precondition";

 	private static final UMLReflection<EPackage, EClassifier, EOperation, EStructuralFeature, EEnumLiteral, EParameter, EObject, CallOperationAction, SendSignalAction, Constraint> umlReflection =
 		EcoreEnvironmentFactory.INSTANCE.createEnvironment().getUMLReflection();

 	public static class Detail
 	{
 		protected final EAnnotation annotation;
 		protected final String key;

 		public Detail(EAnnotation annotation, String key) {
 			this.annotation = annotation;
 			this.key = key;
 		}

 		public EAnnotation getAnnotation() {
 			return annotation;
 		}

 		public EModelElement getContainer() {
 			return (EModelElement) annotation.eContainer();
 		}

 		public String getKey() {
 			return key;
 		}

 		@Override
 		public String toString() {
 			return key + " => ";
 		}
 	}

 	public static class Exporter
 	{
 		protected void addConstraintName(EModelElement constrainedElement, String constraintName) {
 			Set<String> constraintsNameSet = getConstraintNames(constrainedElement);
 			constraintsNameSet.add(constraintName);
 			setConstraintNames(constrainedElement, constraintsNameSet);
 		}

 		public void exportConstraint(BasicEnvironment2 environment, EModelElement constrainedElement, Constraint constraint) {
 			EList<EModelElement> constrainedElements = constraint.getConstrainedElements();
 			if (constrainedElements.isEmpty()) {
 				return;
 			}
 //			EModelElement constrainedElement = constrainedElements.get(0);
 			ExpressionInOCL specification = (ExpressionInOCL) constraint.getSpecification();
 			if (specification == null) {
 				return;
 			}
 			org.eclipse.ocl.expressions.OCLExpression<?> bodyExpression = specification.getBodyExpression();
 			if (bodyExpression == null) {
 				return;
 			}
 			String text = getSourceText(environment, bodyExpression);
 			EOperation ecoreInvariant;
 			if ((constrainedElement instanceof EClass)
 			 && ((ecoreInvariant = EcoreUtils.getEcoreInvariant((EClass)constrainedElement, constraint.getName())) != null)) {
 				setEAnnotation(environment, constraint, ecoreInvariant, OCL_URI, BODY_KEY, text);
 			}
 			else if (constrainedElement instanceof EClassifier) {
 				addConstraintName(constrainedElement, constraint.getName());
 				setEAnnotation(environment, constraint, constrainedElement, OCL_URI, constraint.getName(), text);
 			}
 			else if (constrainedElement instanceof EOperation) {
 				setEAnnotation(environment, constraint, constrainedElement, OCL_URI, BODY_KEY, text);
 			}
 			else if (constrainedElement instanceof EStructuralFeature) {
 				setEAnnotation(environment, constraint, constrainedElement, OCL_URI, DERIVATION_KEY, text);
 			}
 		}

 		protected Set<String> getConstraintNames(EModelElement constrainedElement) {
 			EAnnotation ecoreAnnotation = getEAnnotation(constrainedElement, ECORE_URI);
 			String oldConstraintsDetails = ecoreAnnotation.getDetails().get(CONSTRAINTS_KEY);
 			Set<String> constraintsNameSet = new HashSet<String>();
 			if (oldConstraintsDetails != null) {
 				String[] constraintsNameArray = oldConstraintsDetails.split(" ");  //$NON-NLS-1$
 				for (String constraintsName : constraintsNameArray) {
 					constraintsNameSet.add(constraintsName);
 				}
 			}
 			return constraintsNameSet;
 		}

 		protected EAnnotation getEAnnotation(EModelElement element, String source) {
 			EAnnotation ecoreAnnotation = element.getEAnnotation(source);
 			if (ecoreAnnotation == null) {
 				ecoreAnnotation = EcoreFactory.eINSTANCE.createEAnnotation();
 				ecoreAnnotation.setSource(source);
 				element.getEAnnotations().add(ecoreAnnotation);
 			}
 			return ecoreAnnotation;
 		}

 		protected void removeConstraintName(EModelElement constrainedElement, String constraintName) {
 			Set<String> constraintsNameSet = getConstraintNames(constrainedElement);
 			constraintsNameSet.remove(constraintName);
 			setConstraintNames(constrainedElement, constraintsNameSet);
 		}

 		protected void setEAnnotation(BasicEnvironment2 environment, Constraint constraint, EModelElement constrainedElement, String source, String key, String newValue) {
 		    EAnnotation eAnnotation = getEAnnotation(constrainedElement, source);
 		    EMap<String, String> details = eAnnotation.getDetails();
 			String oldValue = details.get(key);
 		    if (!ClassUtils.equals(oldValue, newValue)) {
 		    	details.put(key, newValue);
 		    }
 	    	int indexOfKey = details.indexOfKey(key);
 		    if (indexOfKey >= 0) {
 		    	Entry<String, String> entry = details.get(indexOfKey);
 		    	CSTNode cstConstraint = environment.getASTMapping(constraint);
 		    	environment.initASTMapping(entry, cstConstraint, null);
 		    }
 		}

 		protected void setConstraintNames(EModelElement constrainedElement, Set<String> constraintsNameSet) {
 			EAnnotation ecoreAnnotation = getEAnnotation(constrainedElement, ECORE_URI);
 			String oldConstraintsDetails = ecoreAnnotation.getDetails().get(CONSTRAINTS_KEY);
 			List<String> constraintNameList = new ArrayList<String>(constraintsNameSet);
 			Collections.sort(constraintNameList);
 			String newConstraintDetails = StringUtils.splice(constraintNameList, " "); //$NON-NLS-1$
 			if (!ClassUtils.equals(oldConstraintsDetails, newConstraintDetails)) {
 				ecoreAnnotation.getDetails().put(CONSTRAINTS_KEY, newConstraintDetails);
 			}
 		}
 	}

 	/**
 	 * Importer creates a textual OCL document from the embedded OCL in a collection of resources.
 	 * <p>
 	 * The text form is available with getText()
 	 * <p>
 	 * A contents mapping for use during synchronization with getContents().
 	 */
 	public static class Importer
 	{
 		private StringBuffer s = new StringBuffer();

 		/**
 		 * The contents identifies every detail of every model element that contributed OCL content that needs
 		 * synchronization on an export back to the ResourceSet.
 		 */
 		private Map<EObject, List<Detail>> contents = new HashMap<EObject, List<Detail>>();

 		public Importer(Collection<? extends Resource> resources) {
 			for (Resource resource : resources) {
 				importEObjectList(resource.getContents());
 			}
 		}

 		protected void appendContent(EObject eContainer, EAnnotation eAnnotation, String detailKey) {
 			List<Detail> details = contents.get(eContainer);
 			if (details == null) {
 				details = new ArrayList<Detail>();
 				contents.put(eContainer, details);
 			}
 			details.add(new Detail(eAnnotation, detailKey));
 		}

 		protected void appendName(ENamedElement eNamedElement) {
 			appendText(eNamedElement.getName());
 		}

 		protected void appendQualifiedName(EOperation eOperation) {
 			appendName(eOperation.getEContainingClass());
 			appendText("::");
 			appendName(eOperation);
 		}

 		protected void appendQualifiedName(EStructuralFeature eStructuralFeature) {
 			appendName(eStructuralFeature.getEContainingClass());
 			appendText("::");
 			appendName(eStructuralFeature);
 		}

 		protected void appendText(String text) {
 			s.append(text);
 		}

 		protected void appendTypeName(ETypedElement eTypedElement) {
 			Object oclType = umlReflection.getOCLType(eTypedElement);
 			appendName((ENamedElement) oclType);
 		}

 		public Map<EObject, List<Detail>> getContents() {
 			return contents;
 		}

 		public String getText() {
 			return s.toString();
 		}

 		protected void importEClassifier(EClassifier eClassifier) {
 			String constraintsString = EcoreUtil.getAnnotation(eClassifier, ECORE_URI, CONSTRAINTS_KEY);
 			if (constraintsString != null) {
 				EAnnotation eAnnotation = eClassifier.getEAnnotation(OCL_URI);
 				if (eAnnotation == null) {
 					return;
 				}
 				EMap<String, String> details = eAnnotation.getDetails();
 				for (String constraintName : constraintsString.split(" ")) {
 					String invariant = details.get(constraintName);
 					if (invariant != null) {
 						appendContent(eClassifier, eAnnotation, constraintName);
 						appendText("\ncontext ");
 						appendName(eClassifier);
 						appendText("\ninv ");
 						appendText(constraintName);
 						appendText(":");
 						appendText(invariant);
 						appendText("\n");
 					}
 				}
 			}
 			if (eClassifier instanceof EClass) {
 				for (EOperation eOperation : ((EClass)eClassifier).getEOperations()) {
 					if (EcoreUtil.isInvariant(eOperation)) {
 						EAnnotation eAnnotation = eOperation.getEAnnotation(OCL_URI);
 						if (eAnnotation != null) {
 							EMap<String, String> details = eAnnotation.getDetails();
 							String invariant = details.get(BODY_KEY);
 							if (invariant != null) {
 								appendContent(eClassifier, eAnnotation, eOperation.getName());
 								appendText("\ncontext ");
 								appendName(eClassifier);
 								appendText("\ninv ");
 								appendName(eOperation);
 								appendText(":");
 								appendText(invariant);
 								appendText("\n");
 							}
 						}
 					}
 				}
 				for (EStructuralFeature eStructuralFeature : ((EClass)eClassifier).getEStructuralFeatures()) {
 					importEStructuralFeature(eStructuralFeature);
 				}
 				for (EOperation eOperation : ((EClass)eClassifier).getEOperations()) {
 					if (!EcoreUtil.isInvariant(eOperation)) {
 						importEOperation(eOperation);
 					}
 				}
 			}
 		}

 		protected void importEObjectList(EList<? extends EObject> contents) {
 			for (EObject eObject : contents) {
 				if (eObject instanceof EPackage) {
 					EPackage ePackage = (EPackage)eObject;
 					importEPackage(ePackage);
 					EList<EPackage> eSubpackages = ePackage.getESubpackages();
 					if (!eSubpackages.isEmpty()) {
 						appendText("\n");
 					}
 					importEObjectList(eSubpackages);
 				}
 			}
 		}

 		protected void importEOperation(EOperation eOperation) {
 			EAnnotation eAnnotation = eOperation.getEAnnotation(OCL_URI);
 			if (eAnnotation == null) {
 				return;
 			}
 			EMap<String, String> details = eAnnotation.getDetails();
 			String pre = details.get(PRECONDITION_KEY);
 			String body = details.get(BODY_KEY);
 			String post = details.get(POSTCONDITION_KEY);
 			if ((pre != null) || (body != null) || (post != null)) {
 				appendText("\ncontext ");
 				appendQualifiedName(eOperation);
 				appendText("(");
 				String prefix = "";
 				for (EParameter eParameter : eOperation.getEParameters()) {
 					appendText(prefix);
 					appendName(eParameter);
 					appendText(" : ");
 					appendTypeName(eParameter);
 					prefix = ", ";
 				}
 				appendText(") : ");
 				appendTypeName(eOperation);
 				appendText("\n");
 			}
 			if (pre != null) {
 				appendContent(eOperation, eAnnotation, PRECONDITION_KEY);
 				appendText("pre:");
 				appendText(pre);
 				appendText("\n");
 			}
 			if (body != null) {
 				appendContent(eOperation, eAnnotation, BODY_KEY);
 				appendText("body:");
 				appendText(body);
 				appendText("\n");
 			}
 			if (post != null) {
 				appendContent(eOperation, eAnnotation, POSTCONDITION_KEY);
 				appendText("post:");
 				appendText(post);
 				appendText("\n");
 			}
 		}

 		protected void importEPackage(EPackage ePackage) {
 			List<String> delegates = new ArrayList<String>();
 			delegates.addAll(EcoreUtil.getInvocationDelegates(ePackage));
 			delegates.addAll(EcoreUtil.getSettingDelegates(ePackage));
 			delegates.addAll(EcoreUtil.getValidationDelegates(ePackage));
 			if (!delegates.contains(OCL_URI)) {
 				return;
 			}
 			appendText("package ");
 			appendName(ePackage);
 			ResourceSet resourceSet = ePackage.eResource().getResourceSet();
 			resourceSet.getPackageRegistry().put(ePackage.getNsURI(), ePackage);
 			appendText("\n");
 			for (EClassifier eClassifier : ePackage.getEClassifiers()) {
 				importEClassifier(eClassifier);
 			}
 			appendText("\nendpackage\n");
 		}

 		protected void importEStructuralFeature(EStructuralFeature eStructuralFeature) {
 			EAnnotation eAnnotation = eStructuralFeature.getEAnnotation(OCL_URI);
 			if (eAnnotation == null) {
 				return;
 			}
 			EMap<String, String> details = eAnnotation.getDetails();
 			String derivation = details.get(DERIVATION_KEY);
 			String initial = details.get(INITIAL_KEY);
 			if ((derivation != null) || (initial != null)) {
 				appendText("\ncontext ");
 				appendQualifiedName(eStructuralFeature);
 				appendText(" : ");
 				appendTypeName(eStructuralFeature);
 				appendText("\n");
 			}
 			if (initial != null) {
 				appendContent(eStructuralFeature, eAnnotation, INITIAL_KEY);
 				appendText("init:");
 				appendText(initial);
 				appendText("\n");
 			}
 			if (derivation != null) {
 				appendContent(eStructuralFeature, eAnnotation, DERIVATION_KEY);
 				appendText("derive:");
 				appendText(derivation);
 				appendText("\n");
 			}
 		}
 	}

 	public class ResourceWatcher extends TracingAdapter
 	{
 		@Override
 		protected void handleNotification(Notification notification) {
 		    int featureID = notification.getFeatureID(Resource.class);
 		    if (featureID == Resource.RESOURCE__IS_MODIFIED) {
 				if (notification.getEventType() == Notification.SET) {
 					importFromResources();
 				}
 		    }
 		}

 		@Override
 		public boolean isAdapterForType(Object type) {
 			return type == ResourceWatcher.class;
 		}
 	}

 	public static OCLInEcoreSynchronizer getAdapter(ResourceSet resourceSet) {
 		return EcoreUtils.getAdapter(resourceSet.eAdapters(), OCLInEcoreSynchronizer.class);
 	}

 	private Exporter exporter = null;		// Non-null while export in progress
 	private Importer importer = null;		// Non-null while import in progress
 	/**
 	 * The contents identifies every detail of every model element that contributed OCL content that needs
 	 * synchronization on an export back to the ResourceSet.
 	 */
 	private Map<EObject, List<Detail>> contents = new HashMap<EObject, List<Detail>>();

 	protected void addWatcher(Object object) {
 		if (object instanceof Resource) {
 			Resource resource = (Resource)object;
 			resource.setTrackingModification(true);
 			ResourceWatcher watcher = EcoreUtils.getAdapter(resource, ResourceWatcher.class);
 			if (watcher == null) {
 				resource.eAdapters().add(new ResourceWatcher());
 			}
 		}
 	}

 	public void exportConstraintsToResource(BasicEnvironment2 environment, List<Constraint> constraints) {
 		try {
 			exporter = new Exporter();
 			Set<Detail> residualDetails = new HashSet<Detail>();
 			for (List<Detail> details : contents.values()) {
 				residualDetails.addAll(details);
 			}
 			//
 			//	First export the constraints that align with imported details.
 			//
 			List<Constraint> residualConstraints = new ArrayList<Constraint>();
 			for (Constraint constraint : constraints) {
 				EList<EModelElement> constrainedElements = constraint.getConstrainedElements();
 				if (!constrainedElements.isEmpty()) {
 					EModelElement constrainedElement = constrainedElements.get(0);
 					String key = constrainedElement instanceof EClassifier ? constraint.getName() :  constraint.getStereotype();
 					List<Detail> details = contents.get(constrainedElement);
 					if (details != null) {
 						for (Detail detail : details){
 							if (key.equals(detail.getKey())) {
 								residualDetails.remove(detail);
 								exporter.exportConstraint(environment, detail.getContainer(), constraint);
 								constrainedElement = null;
 								break;
 							}
 						}
 					}
 					if (constrainedElement != null) {
 						residualConstraints.add(constraint);
 					}
 				}
 			}
 			//
 			//	Now export the residual constraints by aligning the unmatched details in
 			//	sequential order element-wise.
 			//
 			for (Constraint constraint : residualConstraints) {
 				EList<EModelElement> constrainedElements = constraint.getConstrainedElements();
 				EModelElement constrainedElement = constrainedElements.get(0);
 				List<Detail> details = contents.get(constrainedElement);
 				if (details != null) {
 					for (Detail detail : details) {
 //						if (!residualDetails.contains(detail)) {
 //							residualDetails.remove(detail);
 //							break;
 //						}
 						exporter.exportConstraint(environment, detail.getContainer(), constraint);
 					}
 				}
 			}
 			//
 			//	Finally delete the obsolete details
 			//
 			for (Detail detail : residualDetails) {
 				EAnnotation eAnnotation = detail.getAnnotation();
 				EObject eObject = eAnnotation.eContainer();
 				if (eObject instanceof EClassifier) {
 					exporter.removeConstraintName((EClassifier)eObject, detail.getKey());
 				}
 				eAnnotation.getDetails().remove(detail.getKey());
 			}
 		} finally {
 			exporter = null;
 		}
 		importFromResources();
 	}

 	@Override
 	public ResourceSet getTarget() {
 		return (ResourceSet) super.getTarget();
 	}

 	@Override
 	protected void handleNotification(Notification notification) {
 	    int featureID = notification.getFeatureID(ResourceSet.class);
 	    if (featureID == ResourceSet.RESOURCE_SET__RESOURCES)
 	    {
 		    int eventType = notification.getEventType();
 		    if (eventType == Notification.ADD) {
 		    	addWatcher(notification.getNewValue());
 		    }
 		    else if (eventType == Notification.ADD_MANY) {
 		    	for (Object resource : (List<?>)notification.getNewValue()) {
 			    	addWatcher(resource);
 		    	}
 		    }
 		    else if (eventType == Notification.REMOVE) {
 		    	removeWatcher(notification.getOldValue());
 		    }
 		    else if (eventType == Notification.REMOVE_MANY) {
 		    	for (Object resource : (List<?>)notification.getOldValue()) {
 			    	removeWatcher(resource);
 		    	}
 		    }
 	    }
 	}

 	public void importFromResources() {
 		if (exporter != null) {
 			return;
 		}
 		try {
 			importer = new Importer(getTarget().getResources());
 			contents = importer.getContents();
 			String newText = importer.getText();
 			updateDocument(newText);
 		} finally {
 			importer = null;
 		}
 	}

 	@Override
 	public boolean isAdapterForType(Object type) {
 		return type == OCLInEcoreSynchronizer.class;
 	}

 	protected void removeWatcher(Object object) {
 		if (object instanceof Resource) {
 			Resource resource = (Resource)object;
 			ResourceWatcher watcher = EcoreUtils.getAdapter(resource, ResourceWatcher.class);
 			if (watcher != null) {
 				resource.eAdapters().remove(watcher);
 			}
 		}
 	}

 	@Override
 	public void setTarget(Notifier newTarget) {
 		if (getTarget() != null) {
 			for (Resource resource : getTarget().getResources()) {
 				removeWatcher(resource);
 			}
 		}
 		if (newTarget != null) {
 			for (Resource resource : ((ResourceSet)newTarget).getResources()) {
 				addWatcher(resource);
 			}
 		}
 		super.setTarget(newTarget);
 	}

 	@Override
 	public void unsetTarget(Notifier oldTarget) {
 		if (oldTarget != null) {
 			for (Resource resource : ((ResourceSet)oldTarget).getResources()) {
 				removeWatcher(resource);
 			}
 		}
 		super.unsetTarget(oldTarget);
 	}

 	protected abstract void updateDocument(String newText);
 }
	/**
	* <copyright>
	*
	* Copyright (c) 2010 Eclipse Modeling Project and others.
	* 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:
	* E.D.Willink - Initial API and implementation
	*
	* </copyright>
	*
	* $Id: OCLInEcoreSynchronizer.java,v 1.4 2010/03/22 01:23:49 ewillink Exp $
	*/
	package org.eclipse.ocl.examples.editor.ocl.ui.ecore;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Map.Entry;
	import java.util.Set;

	import lpg.runtime.IToken;

	import org.eclipse.emf.common.notify.Notification;
	import org.eclipse.emf.common.notify.Notifier;
	import org.eclipse.emf.common.util.EList;
	import org.eclipse.emf.common.util.EMap;
	import org.eclipse.emf.ecore.EAnnotation;
	import org.eclipse.emf.ecore.EClass;
	import org.eclipse.emf.ecore.EClassifier;
	import org.eclipse.emf.ecore.EEnumLiteral;
	import org.eclipse.emf.ecore.EModelElement;
	import org.eclipse.emf.ecore.ENamedElement;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.EOperation;
	import org.eclipse.emf.ecore.EPackage;
	import org.eclipse.emf.ecore.EParameter;
	import org.eclipse.emf.ecore.EStructuralFeature;
	import org.eclipse.emf.ecore.ETypedElement;
	import org.eclipse.emf.ecore.EcoreFactory;
	import org.eclipse.emf.ecore.resource.Resource;
	import org.eclipse.emf.ecore.resource.ResourceSet;
	import org.eclipse.emf.ecore.util.EcoreUtil;
	import org.eclipse.ocl.cst.CSTNode;
	import org.eclipse.ocl.ecore.CallOperationAction;
	import org.eclipse.ocl.ecore.Constraint;
	import org.eclipse.ocl.ecore.EcoreEnvironmentFactory;
	import org.eclipse.ocl.ecore.ExpressionInOCL;
	import org.eclipse.ocl.ecore.SendSignalAction;
	import org.eclipse.ocl.examples.common.utils.ClassUtils;
	import org.eclipse.ocl.examples.common.utils.EcoreUtils;
	import org.eclipse.ocl.examples.common.utils.StringUtils;
	import org.eclipse.ocl.examples.common.utils.TracingAdapter;
	import org.eclipse.ocl.lpg.BasicEnvironment;
	import org.eclipse.ocl.lpg.BasicEnvironment2;
	import org.eclipse.ocl.utilities.UMLReflection;

	public abstract class OCLInEcoreSynchronizer extends TracingAdapter
	{
	public static String getSourceText(BasicEnvironment environment, Object astNode) {
	CSTNode astMapping = environment.getASTMapping(astNode);
	IToken startToken = astMapping.getStartToken();
	IToken prevToken = startToken.getIPrsStream().getIToken(startToken.getTokenIndex()-1);
	IToken endToken = astMapping.getEndToken();
	IToken[] followingAdjuncts = endToken.getFollowingAdjuncts();
	if ((followingAdjuncts != null) && (followingAdjuncts.length > 0)) {
	endToken = followingAdjuncts[followingAdjuncts.length-1];
	}
	return startToken.getILexStream().toString(prevToken.getEndOffset()+1, endToken.getEndOffset());
	}

	private static final String ECORE_URI = org.eclipse.emf.ecore.EcorePackage.eNS_URI;
	private static final String OCL_URI = ECORE_URI + "/OCL";
	private static final String CONSTRAINTS_KEY = "constraints";
	private static final String BODY_KEY = "body";
	private static final String DERIVATION_KEY = "derivation";
	private static final String INITIAL_KEY = "initial";
	private static final String POSTCONDITION_KEY = "postcondition";
	private static final String PRECONDITION_KEY = "precondition";

	private static final UMLReflection<EPackage, EClassifier, EOperation, EStructuralFeature, EEnumLiteral, EParameter, EObject, CallOperationAction, SendSignalAction, Constraint> umlReflection =
	EcoreEnvironmentFactory.INSTANCE.createEnvironment().getUMLReflection();

	public static class Detail
	{
	protected final EAnnotation annotation;
	protected final String key;

	public Detail(EAnnotation annotation, String key) {
	this.annotation = annotation;
	this.key = key;
	}

	public EAnnotation getAnnotation() {
	return annotation;
	}

	public EModelElement getContainer() {
	return (EModelElement) annotation.eContainer();
	}

	public String getKey() {
	return key;
	}

	@Override
	public String toString() {
	return key + " => ";
	}
	}

	public static class Exporter
	{
	protected void addConstraintName(EModelElement constrainedElement, String constraintName) {
	Set<String> constraintsNameSet = getConstraintNames(constrainedElement);
	constraintsNameSet.add(constraintName);
	setConstraintNames(constrainedElement, constraintsNameSet);
	}

	public void exportConstraint(BasicEnvironment2 environment, EModelElement constrainedElement, Constraint constraint) {
	EList<EModelElement> constrainedElements = constraint.getConstrainedElements();
	if (constrainedElements.isEmpty()) {
	return;
	}
	// EModelElement constrainedElement = constrainedElements.get(0);
	ExpressionInOCL specification = (ExpressionInOCL) constraint.getSpecification();
	if (specification == null) {
	return;
	}
	org.eclipse.ocl.expressions.OCLExpression<?> bodyExpression = specification.getBodyExpression();
	if (bodyExpression == null) {
	return;
	}
	String text = getSourceText(environment, bodyExpression);
	EOperation ecoreInvariant;
	if ((constrainedElement instanceof EClass)
	&& ((ecoreInvariant = EcoreUtils.getEcoreInvariant((EClass)constrainedElement, constraint.getName())) != null)) {
	setEAnnotation(environment, constraint, ecoreInvariant, OCL_URI, BODY_KEY, text);
	}
	else if (constrainedElement instanceof EClassifier) {
	addConstraintName(constrainedElement, constraint.getName());
	setEAnnotation(environment, constraint, constrainedElement, OCL_URI, constraint.getName(), text);
	}
	else if (constrainedElement instanceof EOperation) {
	setEAnnotation(environment, constraint, constrainedElement, OCL_URI, BODY_KEY, text);
	}
	else if (constrainedElement instanceof EStructuralFeature) {
	setEAnnotation(environment, constraint, constrainedElement, OCL_URI, DERIVATION_KEY, text);
	}
	}

	protected Set<String> getConstraintNames(EModelElement constrainedElement) {
	EAnnotation ecoreAnnotation = getEAnnotation(constrainedElement, ECORE_URI);
	String oldConstraintsDetails = ecoreAnnotation.getDetails().get(CONSTRAINTS_KEY);
	Set<String> constraintsNameSet = new HashSet<String>();
	if (oldConstraintsDetails != null) {
	String[] constraintsNameArray = oldConstraintsDetails.split(" "); //$NON-NLS-1$
	for (String constraintsName : constraintsNameArray) {
	constraintsNameSet.add(constraintsName);
	}
	}
	return constraintsNameSet;
	}

	protected EAnnotation getEAnnotation(EModelElement element, String source) {
	EAnnotation ecoreAnnotation = element.getEAnnotation(source);
	if (ecoreAnnotation == null) {
	ecoreAnnotation = EcoreFactory.eINSTANCE.createEAnnotation();
	ecoreAnnotation.setSource(source);
	element.getEAnnotations().add(ecoreAnnotation);
	}
	return ecoreAnnotation;
	}

	protected void removeConstraintName(EModelElement constrainedElement, String constraintName) {
	Set<String> constraintsNameSet = getConstraintNames(constrainedElement);
	constraintsNameSet.remove(constraintName);
	setConstraintNames(constrainedElement, constraintsNameSet);
	}

	protected void setEAnnotation(BasicEnvironment2 environment, Constraint constraint, EModelElement constrainedElement, String source, String key, String newValue) {
	EAnnotation eAnnotation = getEAnnotation(constrainedElement, source);
	EMap<String, String> details = eAnnotation.getDetails();
	String oldValue = details.get(key);
	if (!ClassUtils.equals(oldValue, newValue)) {
	details.put(key, newValue);
	}
	int indexOfKey = details.indexOfKey(key);
	if (indexOfKey >= 0) {
	Entry<String, String> entry = details.get(indexOfKey);
	CSTNode cstConstraint = environment.getASTMapping(constraint);
	environment.initASTMapping(entry, cstConstraint, null);
	}
	}

	protected void setConstraintNames(EModelElement constrainedElement, Set<String> constraintsNameSet) {
	EAnnotation ecoreAnnotation = getEAnnotation(constrainedElement, ECORE_URI);
	String oldConstraintsDetails = ecoreAnnotation.getDetails().get(CONSTRAINTS_KEY);
	List<String> constraintNameList = new ArrayList<String>(constraintsNameSet);
	Collections.sort(constraintNameList);
	String newConstraintDetails = StringUtils.splice(constraintNameList, " "); //$NON-NLS-1$
	if (!ClassUtils.equals(oldConstraintsDetails, newConstraintDetails)) {
	ecoreAnnotation.getDetails().put(CONSTRAINTS_KEY, newConstraintDetails);
	}
	}
	}

	/**
	* Importer creates a textual OCL document from the embedded OCL in a collection of resources.
	* <p>
	* The text form is available with getText()
	* <p>
	* A contents mapping for use during synchronization with getContents().
	*/
	public static class Importer
	{
	private StringBuffer s = new StringBuffer();

	/**
	* The contents identifies every detail of every model element that contributed OCL content that needs
	* synchronization on an export back to the ResourceSet.
	*/
	private Map<EObject, List<Detail>> contents = new HashMap<EObject, List<Detail>>();

	public Importer(Collection<? extends Resource> resources) {
	for (Resource resource : resources) {
	importEObjectList(resource.getContents());
	}
	}

	protected void appendContent(EObject eContainer, EAnnotation eAnnotation, String detailKey) {
	List<Detail> details = contents.get(eContainer);
	if (details == null) {
	details = new ArrayList<Detail>();
	contents.put(eContainer, details);
	}
	details.add(new Detail(eAnnotation, detailKey));
	}

	protected void appendName(ENamedElement eNamedElement) {
	appendText(eNamedElement.getName());
	}

	protected void appendQualifiedName(EOperation eOperation) {
	appendName(eOperation.getEContainingClass());
	appendText("::");
	appendName(eOperation);
	}

	protected void appendQualifiedName(EStructuralFeature eStructuralFeature) {
	appendName(eStructuralFeature.getEContainingClass());
	appendText("::");
	appendName(eStructuralFeature);
	}

	protected void appendText(String text) {
	s.append(text);
	}

	protected void appendTypeName(ETypedElement eTypedElement) {
	Object oclType = umlReflection.getOCLType(eTypedElement);
	appendName((ENamedElement) oclType);
	}

	public Map<EObject, List<Detail>> getContents() {
	return contents;
	}

	public String getText() {
	return s.toString();
	}

	protected void importEClassifier(EClassifier eClassifier) {
	String constraintsString = EcoreUtil.getAnnotation(eClassifier, ECORE_URI, CONSTRAINTS_KEY);
	if (constraintsString != null) {
	EAnnotation eAnnotation = eClassifier.getEAnnotation(OCL_URI);
	if (eAnnotation == null) {
	return;
	}
	EMap<String, String> details = eAnnotation.getDetails();
	for (String constraintName : constraintsString.split(" ")) {
	String invariant = details.get(constraintName);
	if (invariant != null) {
	appendContent(eClassifier, eAnnotation, constraintName);
	appendText("\ncontext ");
	appendName(eClassifier);
	appendText("\ninv ");
	appendText(constraintName);
	appendText(":");
	appendText(invariant);
	appendText("\n");
	}
	}
	}
	if (eClassifier instanceof EClass) {
	for (EOperation eOperation : ((EClass)eClassifier).getEOperations()) {
	if (EcoreUtil.isInvariant(eOperation)) {
	EAnnotation eAnnotation = eOperation.getEAnnotation(OCL_URI);
	if (eAnnotation != null) {
	EMap<String, String> details = eAnnotation.getDetails();
	String invariant = details.get(BODY_KEY);
	if (invariant != null) {
	appendContent(eClassifier, eAnnotation, eOperation.getName());
	appendText("\ncontext ");
	appendName(eClassifier);
	appendText("\ninv ");
	appendName(eOperation);
	appendText(":");
	appendText(invariant);
	appendText("\n");
	}
	}
	}
	}
	for (EStructuralFeature eStructuralFeature : ((EClass)eClassifier).getEStructuralFeatures()) {
	importEStructuralFeature(eStructuralFeature);
	}
	for (EOperation eOperation : ((EClass)eClassifier).getEOperations()) {
	if (!EcoreUtil.isInvariant(eOperation)) {
	importEOperation(eOperation);
	}
	}
	}
	}

	protected void importEObjectList(EList<? extends EObject> contents) {
	for (EObject eObject : contents) {
	if (eObject instanceof EPackage) {
	EPackage ePackage = (EPackage)eObject;
	importEPackage(ePackage);
	EList<EPackage> eSubpackages = ePackage.getESubpackages();
	if (!eSubpackages.isEmpty()) {
	appendText("\n");
	}
	importEObjectList(eSubpackages);
	}
	}
	}

	protected void importEOperation(EOperation eOperation) {
	EAnnotation eAnnotation = eOperation.getEAnnotation(OCL_URI);
	if (eAnnotation == null) {
	return;
	}
	EMap<String, String> details = eAnnotation.getDetails();
	String pre = details.get(PRECONDITION_KEY);
	String body = details.get(BODY_KEY);
	String post = details.get(POSTCONDITION_KEY);
	if ((pre != null) \|\| (body != null) \|\| (post != null)) {
	appendText("\ncontext ");
	appendQualifiedName(eOperation);
	appendText("(");
	String prefix = "";
	for (EParameter eParameter : eOperation.getEParameters()) {
	appendText(prefix);
	appendName(eParameter);
	appendText(" : ");
	appendTypeName(eParameter);
	prefix = ", ";
	}
	appendText(") : ");
	appendTypeName(eOperation);
	appendText("\n");
	}
	if (pre != null) {
	appendContent(eOperation, eAnnotation, PRECONDITION_KEY);
	appendText("pre:");
	appendText(pre);
	appendText("\n");
	}
	if (body != null) {
	appendContent(eOperation, eAnnotation, BODY_KEY);
	appendText("body:");
	appendText(body);
	appendText("\n");
	}
	if (post != null) {
	appendContent(eOperation, eAnnotation, POSTCONDITION_KEY);
	appendText("post:");
	appendText(post);
	appendText("\n");
	}
	}

	protected void importEPackage(EPackage ePackage) {
	List<String> delegates = new ArrayList<String>();
	delegates.addAll(EcoreUtil.getInvocationDelegates(ePackage));
	delegates.addAll(EcoreUtil.getSettingDelegates(ePackage));
	delegates.addAll(EcoreUtil.getValidationDelegates(ePackage));
	if (!delegates.contains(OCL_URI)) {
	return;
	}
	appendText("package ");
	appendName(ePackage);
	ResourceSet resourceSet = ePackage.eResource().getResourceSet();
	resourceSet.getPackageRegistry().put(ePackage.getNsURI(), ePackage);
	appendText("\n");
	for (EClassifier eClassifier : ePackage.getEClassifiers()) {
	importEClassifier(eClassifier);
	}
	appendText("\nendpackage\n");
	}

	protected void importEStructuralFeature(EStructuralFeature eStructuralFeature) {
	EAnnotation eAnnotation = eStructuralFeature.getEAnnotation(OCL_URI);
	if (eAnnotation == null) {
	return;
	}
	EMap<String, String> details = eAnnotation.getDetails();
	String derivation = details.get(DERIVATION_KEY);
	String initial = details.get(INITIAL_KEY);
	if ((derivation != null) \|\| (initial != null)) {
	appendText("\ncontext ");
	appendQualifiedName(eStructuralFeature);
	appendText(" : ");
	appendTypeName(eStructuralFeature);
	appendText("\n");
	}
	if (initial != null) {
	appendContent(eStructuralFeature, eAnnotation, INITIAL_KEY);
	appendText("init:");
	appendText(initial);
	appendText("\n");
	}
	if (derivation != null) {
	appendContent(eStructuralFeature, eAnnotation, DERIVATION_KEY);
	appendText("derive:");
	appendText(derivation);
	appendText("\n");
	}
	}
	}

	public class ResourceWatcher extends TracingAdapter
	{
	@Override
	protected void handleNotification(Notification notification) {
	int featureID = notification.getFeatureID(Resource.class);
	if (featureID == Resource.RESOURCE__IS_MODIFIED) {
	if (notification.getEventType() == Notification.SET) {
	importFromResources();
	}
	}
	}

	@Override
	public boolean isAdapterForType(Object type) {
	return type == ResourceWatcher.class;
	}
	}

	public static OCLInEcoreSynchronizer getAdapter(ResourceSet resourceSet) {
	return EcoreUtils.getAdapter(resourceSet.eAdapters(), OCLInEcoreSynchronizer.class);
	}

	private Exporter exporter = null; // Non-null while export in progress
	private Importer importer = null; // Non-null while import in progress
	/**
	* The contents identifies every detail of every model element that contributed OCL content that needs
	* synchronization on an export back to the ResourceSet.
	*/
	private Map<EObject, List<Detail>> contents = new HashMap<EObject, List<Detail>>();

	protected void addWatcher(Object object) {
	if (object instanceof Resource) {
	Resource resource = (Resource)object;
	resource.setTrackingModification(true);
	ResourceWatcher watcher = EcoreUtils.getAdapter(resource, ResourceWatcher.class);
	if (watcher == null) {
	resource.eAdapters().add(new ResourceWatcher());
	}
	}
	}

	public void exportConstraintsToResource(BasicEnvironment2 environment, List<Constraint> constraints) {
	try {
	exporter = new Exporter();
	Set<Detail> residualDetails = new HashSet<Detail>();
	for (List<Detail> details : contents.values()) {
	residualDetails.addAll(details);
	}
	//
	// First export the constraints that align with imported details.
	//
	List<Constraint> residualConstraints = new ArrayList<Constraint>();
	for (Constraint constraint : constraints) {
	EList<EModelElement> constrainedElements = constraint.getConstrainedElements();
	if (!constrainedElements.isEmpty()) {
	EModelElement constrainedElement = constrainedElements.get(0);
	String key = constrainedElement instanceof EClassifier ? constraint.getName() : constraint.getStereotype();
	List<Detail> details = contents.get(constrainedElement);
	if (details != null) {
	for (Detail detail : details){
	if (key.equals(detail.getKey())) {
	residualDetails.remove(detail);
	exporter.exportConstraint(environment, detail.getContainer(), constraint);
	constrainedElement = null;
	break;
	}
	}
	}
	if (constrainedElement != null) {
	residualConstraints.add(constraint);
	}
	}
	}
	//
	// Now export the residual constraints by aligning the unmatched details in
	// sequential order element-wise.
	//
	for (Constraint constraint : residualConstraints) {
	EList<EModelElement> constrainedElements = constraint.getConstrainedElements();
	EModelElement constrainedElement = constrainedElements.get(0);
	List<Detail> details = contents.get(constrainedElement);
	if (details != null) {
	for (Detail detail : details) {
	// if (!residualDetails.contains(detail)) {
	// residualDetails.remove(detail);
	// break;
	// }
	exporter.exportConstraint(environment, detail.getContainer(), constraint);
	}
	}
	}
	//
	// Finally delete the obsolete details
	//
	for (Detail detail : residualDetails) {
	EAnnotation eAnnotation = detail.getAnnotation();
	EObject eObject = eAnnotation.eContainer();
	if (eObject instanceof EClassifier) {
	exporter.removeConstraintName((EClassifier)eObject, detail.getKey());
	}
	eAnnotation.getDetails().remove(detail.getKey());
	}
	} finally {
	exporter = null;
	}
	importFromResources();
	}

	@Override
	public ResourceSet getTarget() {
	return (ResourceSet) super.getTarget();
	}

	@Override
	protected void handleNotification(Notification notification) {
	int featureID = notification.getFeatureID(ResourceSet.class);
	if (featureID == ResourceSet.RESOURCE_SET__RESOURCES)
	{
	int eventType = notification.getEventType();
	if (eventType == Notification.ADD) {
	addWatcher(notification.getNewValue());
	}
	else if (eventType == Notification.ADD_MANY) {
	for (Object resource : (List<?>)notification.getNewValue()) {
	addWatcher(resource);
	}
	}
	else if (eventType == Notification.REMOVE) {
	removeWatcher(notification.getOldValue());
	}
	else if (eventType == Notification.REMOVE_MANY) {
	for (Object resource : (List<?>)notification.getOldValue()) {
	removeWatcher(resource);
	}
	}
	}
	}

	public void importFromResources() {
	if (exporter != null) {
	return;
	}
	try {
	importer = new Importer(getTarget().getResources());
	contents = importer.getContents();
	String newText = importer.getText();
	updateDocument(newText);
	} finally {
	importer = null;
	}
	}

	@Override
	public boolean isAdapterForType(Object type) {
	return type == OCLInEcoreSynchronizer.class;
	}

	protected void removeWatcher(Object object) {
	if (object instanceof Resource) {
	Resource resource = (Resource)object;
	ResourceWatcher watcher = EcoreUtils.getAdapter(resource, ResourceWatcher.class);
	if (watcher != null) {
	resource.eAdapters().remove(watcher);
	}
	}
	}

	@Override
	public void setTarget(Notifier newTarget) {
	if (getTarget() != null) {
	for (Resource resource : getTarget().getResources()) {
	removeWatcher(resource);
	}
	}
	if (newTarget != null) {
	for (Resource resource : ((ResourceSet)newTarget).getResources()) {
	addWatcher(resource);
	}
	}
	super.setTarget(newTarget);
	}

	@Override
	public void unsetTarget(Notifier oldTarget) {
	if (oldTarget != null) {
	for (Resource resource : ((ResourceSet)oldTarget).getResources()) {
	removeWatcher(resource);
	}
	}
	super.unsetTarget(oldTarget);
	}

	protected abstract void updateDocument(String newText);
	}