plugins/org.eclipse.ocl.pivot/src/org/eclipse/ocl/pivot/internal/resource/ASResourceImpl.java - ocl/org.eclipse.ocl - Git at Google

 /*******************************************************************************
  * Copyright (c) 2010, 2022 Willink Transformations and others.
  * All rights reserved.   This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v2.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v20.html
  *
  * Contributors:
  *   E.D.Willink - Initial API and implementation
  *******************************************************************************/
 package org.eclipse.ocl.pivot.internal.resource;

 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.util.HashMap;
 import java.util.Map;

 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
 import org.eclipse.emf.common.notify.Notifier;
 import org.eclipse.emf.common.notify.impl.AdapterImpl;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.common.util.TreeIterator;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.InternalEObject;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.ecore.resource.ResourceSet;
 import org.eclipse.emf.ecore.xmi.XMLSave;
 import org.eclipse.emf.ecore.xmi.impl.XMIHelperImpl;
 import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.ocl.pivot.Constraint;
 import org.eclipse.ocl.pivot.Element;
 import org.eclipse.ocl.pivot.ExpressionInOCL;
 import org.eclipse.ocl.pivot.Feature;
 import org.eclipse.ocl.pivot.InvalidType;
 import org.eclipse.ocl.pivot.Model;
 import org.eclipse.ocl.pivot.PivotPackage;
 import org.eclipse.ocl.pivot.Property;
 import org.eclipse.ocl.pivot.internal.utilities.PivotObjectImpl;
 import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal;
 import org.eclipse.ocl.pivot.resource.ASResource;
 import org.eclipse.ocl.pivot.util.PivotPlugin;
 import org.eclipse.ocl.pivot.utilities.PivotConstants;
 import org.eclipse.ocl.pivot.utilities.TracingAdapter;
 import org.eclipse.ocl.pivot.utilities.TracingOption;
 import org.eclipse.ocl.pivot.utilities.TreeIterable;
 import org.eclipse.ocl.pivot.utilities.XMIUtil;

 /**
  * ASResourceImpl is the mandatory implementation of the ASResource interface that refines an
  * a standard EMF XMIResource to be used as a Pivot AS Resource.
  * @author ed
  *
  */
 public class ASResourceImpl extends XMIResourceImpl implements ASResource
 {
 	/**
 	 * If CHECK_IMMUTABILITY is set active, an ImmutabilityCheckingAdapter instance is installed for all
 	 * contents of any ASREsource that is set not-saveable. Any mutation then causes an IllegalStateException.
 	 *
 	 * @since 1.5
 	 */
 	public static final TracingOption CHECK_IMMUTABILITY = new TracingOption(PivotPlugin.PLUGIN_ID, "resource/checkImmutability"); //$NON-NLS-1$

 	/**
 	 * QVTd JUnit tests may set this false to load the saved XMI as text for validation that it is free of
 	 * references to undeclared xmi:ids. The OCL JUnit tests do not have sufficient referential complexity to have problems.
 	 * See Bug 578030.
 	 *
 	 * @since 1.18
 	 */
 	public static boolean SKIP_CHECK_BAD_REFERENCES = false;

 	/**
 	 * An adapter implementation for tracking resource modification. This is only in use if the
 	 * "resource/checkImmutability" .option is set as is the case for JUnit tests.
 	 *
 	 * @since 1.18
 	 */
 	protected class ImmutabilityCheckingAdapter extends AdapterImpl
 	{
 		private @NonNull String formatMutationMessage(@NonNull Notification notification) {
 			StringBuilder s = new StringBuilder();
 			s.append("'");
 			s.append(ASResourceImpl.this.getURI());
 			s.append("' modified at a '");
 			s.append(TracingAdapter.getFeatureType(notification));
 			s.append("'");
 			return s.toString();
 		}

 		@Override
 		public void notifyChanged(Notification notification) {			// FIXME All irregularitoes should be transient
 			if (!notification.isTouch() && !ASResourceImpl.this.isUpdating && !ASResourceImpl.this.isUnloading) {
 				Object notifier = notification.getNotifier();
 				Object feature = notification.getFeature();
 				int eventType = notification.getEventType();
 				if (eventType == Notification.ADD) {
 					if (notifier instanceof Resource) {
 						int featureID = notification.getFeatureID(Resource.class);		// Occurs after unloading has finished
 						if (featureID == RESOURCE__ERRORS) {
 							return;
 						}
 						if (featureID == RESOURCE__WARNINGS) {
 							return;
 						}
 					}
 					else if (notifier instanceof Element) {
 						if (feature == PivotPackage.Literals.ELEMENT__OWNED_EXTENSIONS) {
 							return;
 						}
 						else if (notifier instanceof ExpressionInOCL) {						// A known safe laziness See Bug 535888#c6 and Bug 551822#c2
 							if (feature == PivotPackage.Literals.EXPRESSION_IN_OCL__OWNED_PARAMETERS) {
 								return;
 							}
 						}
 						else if (notifier instanceof org.eclipse.ocl.pivot.Class) {
 							if (feature == PivotPackage.Literals.CLASS__OWNED_PROPERTIES) {
 								Object newValue = notification.getNewValue();
 								if ((newValue instanceof Property) && ((Property)newValue).isIsImplicit()) {	// Late QVTr trace properties
 									return;
 								}
 								return;
 							}
 							else if (notifier instanceof InvalidType) {						// A known safe laziness See Bug 579037#c2
 								//		return;
 							}
 						}
 					}
 				}
 				else if (eventType == Notification.REMOVE) {
 					if (notifier instanceof org.eclipse.ocl.pivot.Class) {
 						if (feature == PivotPackage.Literals.CLASS__OWNED_PROPERTIES) {
 							Object oldValue = notification.getOldValue();
 							if ((oldValue instanceof Property) && ((Property)oldValue).isIsImplicit()) {	// Late QVTr trace properties
 								return;
 							}
 							return;
 						}
 					}
 				}
 				else if (eventType == Notification.SET) {
 					if (notifier instanceof Resource) {
 						int featureID = notification.getFeatureID(Resource.class);		// Occurs after unloading has finished
 						if (featureID == RESOURCE__IS_LOADED) {
 							return;
 						}
 					//	if (featureID == RESOURCE__URI) {
 					//		return;
 					//	}
 						if (featureID == RESOURCE__TIME_STAMP) {
 							return;
 						}
 					//	Resource resource = (Resource)notifier;
 					//	if (!resource.isLoaded()) {
 					//		return;
 					//	}
 					}
 					else if (notifier instanceof Feature) {
 						if (feature == PivotPackage.Literals.FEATURE__IMPLEMENTATION) {	// A known safe transient See Bug 535888#c6 and Bug 551822#c2
 							Object oldValue = notification.getOldValue();
 							if (oldValue == null) {
 								return;
 							}
 						}
 						if ((notifier instanceof Property) && ((Property)notifier).isIsImplicit()) {	// Occurs when unloading QVTr trace properties
 				//			return;
 						}
 					}
 					else if (notifier instanceof Constraint) {
 						if (feature == PivotPackage.Literals.CONSTRAINT__OWNED_SPECIFICATION) {
 							return;
 						}
 					}
 					else if (notifier instanceof ExpressionInOCL) {					// A known safe laziness See Bug 535888#c6
 						if (feature == PivotPackage.Literals.EXPRESSION_IN_OCL__OWNED_BODY) {
 							return;
 						}
 						if (feature == PivotPackage.Literals.EXPRESSION_IN_OCL__OWNED_CONTEXT) {
 							return;
 						}
 						if (feature == PivotPackage.Literals.EXPRESSION_IN_OCL__OWNED_RESULT) {
 							return;
 						}
 						if (feature == PivotPackage.Literals.LANGUAGE_EXPRESSION__BODY) {
 							return;
 						}
 						if (feature == PivotPackage.Literals.LANGUAGE_EXPRESSION__OWNING_CONSTRAINT) {
 							return;
 						}
 						if (feature == PivotPackage.Literals.TYPED_ELEMENT__IS_REQUIRED) {
 							return;
 						}
 						if (feature == PivotPackage.Literals.TYPED_ELEMENT__TYPE) {
 							return;
 						}
 					}
 				}
 				// Drop through for nearly everything including REMOVE - see Bug 541380#c6
 				throw new IllegalStateException(formatMutationMessage(notification));
 			}
 		}

 		@Override
 		public void setTarget(Notifier newTarget) {}

 		@Override
 		public void unsetTarget(Notifier oldTarget) {}
 	}

 	/**
 	 * ImmutableResource provides additional API for derived ReadOnly/Immutable implementations.
 	 *
 	 * @since 1.5
 	 */
 	public static interface ImmutableResource
 	{
 		/**
 		 * Return true if this Immutable/ReadOnly Resource is compatible with the given metamodelURI.
 		 * This is typically used to allow a metamodelURI implementation to be re-used rather than cloned.
 		 */
 		boolean isCompatibleWith(@NonNull String metamodelURI);
 	}

 	/**
 	 * @since 1.5
 	 */
 	private @Nullable ImmutabilityCheckingAdapter immutabilityCheckingAdapter = null;

 	protected final @NonNull ASResourceFactory asResourceFactory;
 	private @Nullable LUSSIDs lussids = null;
 	private @Nullable Map<@NonNull String, @NonNull EObject> legacyXMIId2eObject = null;

 	/**
 	 * An attempt to save an unsaveable ASResource is ignored, probably because it is immuatble..
 	 */
 	private boolean isSaveable = true;

 	/**
 	 * Set true during doUnload()
 	 */
 	private boolean isUnloading = false;

 	/**
 	 * Set true/false by setUpdating()(
 	 */
 	private boolean isUpdating = false;

 	/**
 	 * Creates an instance of the resource.
 	 */
 	public ASResourceImpl(@NonNull URI uri, @NonNull ASResourceFactory asResourceFactory) {
 		super(uri);
 		this.asResourceFactory = asResourceFactory;
 		assert PivotUtilInternal.isASURI(uri);
 		//		PivotUtilInternal.debugPrintln("Create " + NameUtil.debugSimpleName(this) + " : " + uri);
 	}

 	/**
 	 * @since 1.4
 	 */
 	@Override
 	public @Nullable EObject basicGetEObjectByID(@Nullable String id) {
 		return idToEObjectMap != null ? idToEObjectMap.get(id) : null;
 	}

 	/**
 	 * @since 1.4
 	 */
 	@Override
 	public @Nullable LUSSIDs basicGetLUSSIDs() {
 		return lussids;
 	}

 	/**
 	 * Overridden to ensure that the ResourceFactoryRegistry ExtensionToFactoryMap entries for AS file extensions
 	 * have ASResourceFactory instnaces that are able to fall back from AS extension to CS extension using the
 	 * resourceSet as the AS ResourceSet for OCL parsing.
 	 */
 	@Override
 	public NotificationChain basicSetResourceSet(ResourceSet resourceSet, NotificationChain notifications) {
 		NotificationChain notificationChain = super.basicSetResourceSet(resourceSet, notifications);
 		if (resourceSet != null) {
 			String fileExtension = getURI().fileExtension();
 			if (fileExtension != null) {
 				Object resourceFactory = resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap().get(fileExtension);
 				if (resourceFactory == null) {
 					ASResourceFactoryRegistry.INSTANCE.configureResourceFactoryRegistry(resourceSet);
 				}
 			}
 		}
 		return notificationChain;
 	}

 	/**
 	 * @since 1.18
 	 */
 	protected @NonNull ImmutabilityCheckingAdapter createImmutabilityCheckingAdapter() {
 		return new ImmutabilityCheckingAdapter();
 	}

 	@Override
 	protected XMLSave createXMLSave() {
 		return new PivotSaveImpl(new XMIHelperImpl(this)
 		{
 			@Override
 			public String getHREF(EObject obj) {
 				if (obj instanceof Property) {			// Avoid generating a referemce to an EObject that might not exist
 					Property asProperty = (Property)obj;
 					if (asProperty.isIsImplicit() && (asProperty.getOpposite() != null)) {
 						return null;
 					}
 				}
 				return super.getHREF(obj);
 			}
 		});
 	}

 	@Override
 	protected void doUnload() {
 		isUnloading = true;
 		try {
 			super.doUnload();
 			if (lussids != null) {
 				resetLUSSIDs();
 			}
 		}
 		finally {
 			isUnloading = false;
 		}
 	}

 	@Override
 	public @NonNull ASResourceFactory getASResourceFactory() {
 		return asResourceFactory;
 	}

 	@Override
 	public @NonNull Map<Object, Object> getDefaultSaveOptions() {
 		Map<Object, Object> defaultSaveOptions2 = defaultSaveOptions;
 		if (defaultSaveOptions2 == null) {
 			defaultSaveOptions = defaultSaveOptions2 = XMIUtil.createPivotSaveOptions();
 		}
 		return defaultSaveOptions2;
 	}

 	@SuppressWarnings("deprecation")
 	@Override
 	protected EObject getEObjectByID(String id) {
 		if ((unloadingContents == null) && (idToEObjectMap == null)) { // Lazy xmi:id creation needed by generated ASResources
 			AS2ID.assignIds(this, null);
 		}
 		if (idToEObjectMap == null) {
 			return null;
 		}
 		EObject eObject = idToEObjectMap.get(id);
 		if (eObject != null) {
 			return eObject;
 		}
 		if (isLoading()) {
 			return null;
 		}
 		// FIXME Use getXmiidVersion() to select appropriate algorithm
 		Map<@NonNull String, @NonNull EObject> legacyXMIId2eObject2 = legacyXMIId2eObject;
 		if (legacyXMIId2eObject2 == null) {
 			org.eclipse.ocl.pivot.internal.utilities.AS2XMIid as2id = new org.eclipse.ocl.pivot.internal.utilities.AS2XMIid();
 			legacyXMIId2eObject = legacyXMIId2eObject2 = new HashMap<>();
 			for (EObject eObject2 : new TreeIterable(this)) {
 				if (eObject2 instanceof Element) {
 					Element element = (Element)eObject2;
 					org.eclipse.ocl.pivot.utilities.AS2XMIidVisitor idVisitor = asResourceFactory.createAS2XMIidVisitor(as2id);
 					Boolean status = element.accept(idVisitor);
 					if (status == Boolean.TRUE) {
 						String legacyId = idVisitor.toString();
 						if (legacyId != null) {
 							legacyXMIId2eObject2.put(legacyId,  eObject2);;
 						}
 					}
 				}
 			}
 		}
 		EObject eObject2 = legacyXMIId2eObject2.get(id);
 		return eObject2;
 	}

 	/**
 	 * @since 1.4
 	 */
 	@Override
 	public @NonNull LUSSIDs getLUSSIDs(@NonNull Map<@NonNull Object, @Nullable Object> options) {
 		LUSSIDs lussids2 = lussids;
 		if (lussids2 == null) {
 			lussids = lussids2 = ((ASResourceFactory.ASResourceFactoryExtension)asResourceFactory).createLUSSIDs(this, options);
 		}
 		return lussids2;
 	}

 	@Override
 	public @NonNull Model getModel() {
 		EList<EObject> contents = getContents();
 		if (contents.size() <= 0) {
 			throw new IllegalStateException("No Model at root of empty '" + getURI() + "'");
 		}
 		EObject eObject = contents.get(0);
 		if (!(eObject instanceof Model)) {
 			throw new IllegalStateException("Non-Model at root of '" + getURI() + "'");
 		}
 		return (Model)eObject;
 	}

 	@Override
 	public String getURIFragment(EObject eObject) {
 		if ((unloadingContents == null) && (idToEObjectMap == null)) {
 			AS2ID.assignIds(this, null);
 		}
 		return super.getURIFragment(eObject);
 	}

 	/**
 	 * @since 1.4
 	 */
 	@Override
 	public int getXmiidVersion() {
 		for (EObject eRoot : getContents()) {
 			if (eRoot instanceof Model) {
 				Number xmiidVersion = ((Model)eRoot).getXmiidVersion();
 				if (xmiidVersion != null) {
 					return xmiidVersion.intValue();
 				}
 			}
 		}
 		return 0;
 	}

 	/**
 	 * Read the serialized representation to confirm that all external references
 	 * use an xmi:id to enhance persistence in the case of model evolution.
 	 */
 	private boolean isFreeOfBadReferences() throws IOException {
 		InputStream inputStream = getResourceSet().getURIConverter().createInputStream(uri);
 		Reader reader = new InputStreamReader(inputStream);
 		StringBuilder s = new StringBuilder();
 		char[] buf = new char[4096];
 		for (int len; (len = reader.read(buf)) > 0; ) {
 			s.append(buf, 0, len);
 		}
 		reader.close();
 		String string = s.toString();
 		int index = string.indexOf(";#//@");
 		if (index < 0) {
 			return true;
 		}
 		int preIndex = string.lastIndexOf("\n", index);
 		int postIndex = string.indexOf("\n", index);
 		String refText = string.substring(preIndex, postIndex).trim();
 		System.err.println("Missing xmi:id for reference in \'" + uri + "'\n\t" + refText);
 		// PivotLUSSIDs.isExternallyReferenceable determines what gets xmi:ids
 		return false;
 	}

 	@Override
 	public boolean isOrphanage() {
 		return false;
 	}

 	@Override
 	public boolean isSaveable() {
 		return isSaveable;
 	}

 	/**
 	 * @since 1.4
 	 */
 	@Override
 	public void resetLUSSIDs() {
 		LUSSIDs lussids2 = lussids;
 		if (lussids2 != null) {
 			lussids = null;
 			//	System.out.println("resetLUSSIDs for "  + getURI());
 			lussids2.dispose();
 		}
 	}

 	/**
 	 * Overridden to suppress saving unsaveable content to a probably read-only destination.
 	 */
 	@Override
 	public void save(Map<?, ?> options) throws IOException {
 		if (isSaveable) {
 			setXmiidVersion(PivotConstants.XMIIDS_CURRENT);
 			if (options == null) {
 				options = getDefaultSaveOptions();
 			}
 			XMIUtil.IdResourceEntityHandler.reset(options);
 			super.save(options);
 			assert SKIP_CHECK_BAD_REFERENCES || isFreeOfBadReferences();
 		}
 	}

 	/**
 	 * @since 1.5
 	 */
 	@Override
 	public boolean setSaveable(boolean isSaveable) {
 		boolean wasSaveable = this.isSaveable;
 		this.isSaveable = isSaveable;
 		if (isSaveable) {
 			if (immutabilityCheckingAdapter != null) {
 				this.eAdapters().remove(immutabilityCheckingAdapter);
 				for (TreeIterator<EObject> i = getAllProperContents(getContents()); i.hasNext(); ) {
 					EObject eObject = i.next();
 					eObject.eAdapters().remove(immutabilityCheckingAdapter);
 				}
 				immutabilityCheckingAdapter = null;
 			}
 		}
 		else if (wasSaveable && CHECK_IMMUTABILITY.isActive()) {
 			if (immutabilityCheckingAdapter == null) {
 				immutabilityCheckingAdapter = createImmutabilityCheckingAdapter();
 			}
 			for (TreeIterator<EObject> i = getAllProperContents(getContents()); i.hasNext(); ) {
 				EObject eObject = i.next();
 				eObject.eAdapters().add(immutabilityCheckingAdapter);
 			}
 			this.eAdapters().add(immutabilityCheckingAdapter);
 		}
 		return wasSaveable;
 	}

 	@Override
 	public boolean setUpdating(boolean isUpdating) {
 		boolean wasUpdating = this.isUpdating;
 		this.isUpdating = isUpdating;
 		return wasUpdating;
 	}

 	/**
 	 * @since 1.4
 	 */
 	@Override
 	public void setXmiidVersion(int xmiidVersion) {
 		for (EObject eRoot : getContents()) {
 			if (eRoot instanceof Model) {
 				((Model)eRoot).setXmiidVersion(xmiidVersion);
 			}
 		}
 	}

 	/**
 	 * @since 1.18
 	 */
 	protected String superGetURIFragment(EObject eObject) {
 		return super.getURIFragment(eObject);		// Bypass assignIds for use by OrphanResource
 	}

 	@Override
 	protected void unloaded(InternalEObject internalEObject) {
 		if (internalEObject instanceof PivotObjectImpl) {
 			((PivotObjectImpl)internalEObject).unloaded(this);
 		}
 		super.unloaded(internalEObject);
 	}

 	@Override
 	protected boolean useIDAttributes() {
 		return false;
 	}

 	@Override
 	protected boolean useIDs() {
 		return true;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2010, 2022 Willink Transformations and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v2.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v20.html
	*
	* Contributors:
	* E.D.Willink - Initial API and implementation
	*******************************************************************************/
	package org.eclipse.ocl.pivot.internal.resource;

	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.Reader;
	import java.util.HashMap;
	import java.util.Map;

	import org.eclipse.emf.common.notify.Notification;
	import org.eclipse.emf.common.notify.NotificationChain;
	import org.eclipse.emf.common.notify.Notifier;
	import org.eclipse.emf.common.notify.impl.AdapterImpl;
	import org.eclipse.emf.common.util.EList;
	import org.eclipse.emf.common.util.TreeIterator;
	import org.eclipse.emf.common.util.URI;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.InternalEObject;
	import org.eclipse.emf.ecore.resource.Resource;
	import org.eclipse.emf.ecore.resource.ResourceSet;
	import org.eclipse.emf.ecore.xmi.XMLSave;
	import org.eclipse.emf.ecore.xmi.impl.XMIHelperImpl;
	import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl;
	import org.eclipse.jdt.annotation.NonNull;
	import org.eclipse.jdt.annotation.Nullable;
	import org.eclipse.ocl.pivot.Constraint;
	import org.eclipse.ocl.pivot.Element;
	import org.eclipse.ocl.pivot.ExpressionInOCL;
	import org.eclipse.ocl.pivot.Feature;
	import org.eclipse.ocl.pivot.InvalidType;
	import org.eclipse.ocl.pivot.Model;
	import org.eclipse.ocl.pivot.PivotPackage;
	import org.eclipse.ocl.pivot.Property;
	import org.eclipse.ocl.pivot.internal.utilities.PivotObjectImpl;
	import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal;
	import org.eclipse.ocl.pivot.resource.ASResource;
	import org.eclipse.ocl.pivot.util.PivotPlugin;
	import org.eclipse.ocl.pivot.utilities.PivotConstants;
	import org.eclipse.ocl.pivot.utilities.TracingAdapter;
	import org.eclipse.ocl.pivot.utilities.TracingOption;
	import org.eclipse.ocl.pivot.utilities.TreeIterable;
	import org.eclipse.ocl.pivot.utilities.XMIUtil;

	/**
	* ASResourceImpl is the mandatory implementation of the ASResource interface that refines an
	* a standard EMF XMIResource to be used as a Pivot AS Resource.
	* @author ed
	*
	*/
	public class ASResourceImpl extends XMIResourceImpl implements ASResource
	{
	/**
	* If CHECK_IMMUTABILITY is set active, an ImmutabilityCheckingAdapter instance is installed for all
	* contents of any ASREsource that is set not-saveable. Any mutation then causes an IllegalStateException.
	*
	* @since 1.5
	*/
	public static final TracingOption CHECK_IMMUTABILITY = new TracingOption(PivotPlugin.PLUGIN_ID, "resource/checkImmutability"); //$NON-NLS-1$

	/**
	* QVTd JUnit tests may set this false to load the saved XMI as text for validation that it is free of
	* references to undeclared xmi:ids. The OCL JUnit tests do not have sufficient referential complexity to have problems.
	* See Bug 578030.
	*
	* @since 1.18
	*/
	public static boolean SKIP_CHECK_BAD_REFERENCES = false;

	/**
	* An adapter implementation for tracking resource modification. This is only in use if the
	* "resource/checkImmutability" .option is set as is the case for JUnit tests.
	*
	* @since 1.18
	*/
	protected class ImmutabilityCheckingAdapter extends AdapterImpl
	{
	private @NonNull String formatMutationMessage(@NonNull Notification notification) {
	StringBuilder s = new StringBuilder();
	s.append("'");
	s.append(ASResourceImpl.this.getURI());
	s.append("' modified at a '");
	s.append(TracingAdapter.getFeatureType(notification));
	s.append("'");
	return s.toString();
	}

	@Override
	public void notifyChanged(Notification notification) { // FIXME All irregularitoes should be transient
	if (!notification.isTouch() && !ASResourceImpl.this.isUpdating && !ASResourceImpl.this.isUnloading) {
	Object notifier = notification.getNotifier();
	Object feature = notification.getFeature();
	int eventType = notification.getEventType();
	if (eventType == Notification.ADD) {
	if (notifier instanceof Resource) {
	int featureID = notification.getFeatureID(Resource.class); // Occurs after unloading has finished
	if (featureID == RESOURCE__ERRORS) {
	return;
	}
	if (featureID == RESOURCE__WARNINGS) {
	return;
	}
	}
	else if (notifier instanceof Element) {
	if (feature == PivotPackage.Literals.ELEMENT__OWNED_EXTENSIONS) {
	return;
	}
	else if (notifier instanceof ExpressionInOCL) { // A known safe laziness See Bug 535888#c6 and Bug 551822#c2
	if (feature == PivotPackage.Literals.EXPRESSION_IN_OCL__OWNED_PARAMETERS) {
	return;
	}
	}
	else if (notifier instanceof org.eclipse.ocl.pivot.Class) {
	if (feature == PivotPackage.Literals.CLASS__OWNED_PROPERTIES) {
	Object newValue = notification.getNewValue();
	if ((newValue instanceof Property) && ((Property)newValue).isIsImplicit()) { // Late QVTr trace properties
	return;
	}
	return;
	}
	else if (notifier instanceof InvalidType) { // A known safe laziness See Bug 579037#c2
	// return;
	}
	}
	}
	}
	else if (eventType == Notification.REMOVE) {
	if (notifier instanceof org.eclipse.ocl.pivot.Class) {
	if (feature == PivotPackage.Literals.CLASS__OWNED_PROPERTIES) {
	Object oldValue = notification.getOldValue();
	if ((oldValue instanceof Property) && ((Property)oldValue).isIsImplicit()) { // Late QVTr trace properties
	return;
	}
	return;
	}
	}
	}
	else if (eventType == Notification.SET) {
	if (notifier instanceof Resource) {
	int featureID = notification.getFeatureID(Resource.class); // Occurs after unloading has finished
	if (featureID == RESOURCE__IS_LOADED) {
	return;
	}
	// if (featureID == RESOURCE__URI) {
	// return;
	// }
	if (featureID == RESOURCE__TIME_STAMP) {
	return;
	}
	// Resource resource = (Resource)notifier;
	// if (!resource.isLoaded()) {
	// return;
	// }
	}
	else if (notifier instanceof Feature) {
	if (feature == PivotPackage.Literals.FEATURE__IMPLEMENTATION) { // A known safe transient See Bug 535888#c6 and Bug 551822#c2
	Object oldValue = notification.getOldValue();
	if (oldValue == null) {
	return;
	}
	}
	if ((notifier instanceof Property) && ((Property)notifier).isIsImplicit()) { // Occurs when unloading QVTr trace properties
	// return;
	}
	}
	else if (notifier instanceof Constraint) {
	if (feature == PivotPackage.Literals.CONSTRAINT__OWNED_SPECIFICATION) {
	return;
	}
	}
	else if (notifier instanceof ExpressionInOCL) { // A known safe laziness See Bug 535888#c6
	if (feature == PivotPackage.Literals.EXPRESSION_IN_OCL__OWNED_BODY) {
	return;
	}
	if (feature == PivotPackage.Literals.EXPRESSION_IN_OCL__OWNED_CONTEXT) {
	return;
	}
	if (feature == PivotPackage.Literals.EXPRESSION_IN_OCL__OWNED_RESULT) {
	return;
	}
	if (feature == PivotPackage.Literals.LANGUAGE_EXPRESSION__BODY) {
	return;
	}
	if (feature == PivotPackage.Literals.LANGUAGE_EXPRESSION__OWNING_CONSTRAINT) {
	return;
	}
	if (feature == PivotPackage.Literals.TYPED_ELEMENT__IS_REQUIRED) {
	return;
	}
	if (feature == PivotPackage.Literals.TYPED_ELEMENT__TYPE) {
	return;
	}
	}
	}
	// Drop through for nearly everything including REMOVE - see Bug 541380#c6
	throw new IllegalStateException(formatMutationMessage(notification));
	}
	}

	@Override
	public void setTarget(Notifier newTarget) {}

	@Override
	public void unsetTarget(Notifier oldTarget) {}
	}

	/**
	* ImmutableResource provides additional API for derived ReadOnly/Immutable implementations.
	*
	* @since 1.5
	*/
	public static interface ImmutableResource
	{
	/**
	* Return true if this Immutable/ReadOnly Resource is compatible with the given metamodelURI.
	* This is typically used to allow a metamodelURI implementation to be re-used rather than cloned.
	*/
	boolean isCompatibleWith(@NonNull String metamodelURI);
	}

	/**
	* @since 1.5
	*/
	private @Nullable ImmutabilityCheckingAdapter immutabilityCheckingAdapter = null;

	protected final @NonNull ASResourceFactory asResourceFactory;
	private @Nullable LUSSIDs lussids = null;
	private @Nullable Map<@NonNull String, @NonNull EObject> legacyXMIId2eObject = null;

	/**
	* An attempt to save an unsaveable ASResource is ignored, probably because it is immuatble..
	*/
	private boolean isSaveable = true;

	/**
	* Set true during doUnload()
	*/
	private boolean isUnloading = false;

	/**
	* Set true/false by setUpdating()(
	*/
	private boolean isUpdating = false;

	/**
	* Creates an instance of the resource.
	*/
	public ASResourceImpl(@NonNull URI uri, @NonNull ASResourceFactory asResourceFactory) {
	super(uri);
	this.asResourceFactory = asResourceFactory;
	assert PivotUtilInternal.isASURI(uri);
	// PivotUtilInternal.debugPrintln("Create " + NameUtil.debugSimpleName(this) + " : " + uri);
	}

	/**
	* @since 1.4
	*/
	@Override
	public @Nullable EObject basicGetEObjectByID(@Nullable String id) {
	return idToEObjectMap != null ? idToEObjectMap.get(id) : null;
	}

	/**
	* @since 1.4
	*/
	@Override
	public @Nullable LUSSIDs basicGetLUSSIDs() {
	return lussids;
	}

	/**
	* Overridden to ensure that the ResourceFactoryRegistry ExtensionToFactoryMap entries for AS file extensions
	* have ASResourceFactory instnaces that are able to fall back from AS extension to CS extension using the
	* resourceSet as the AS ResourceSet for OCL parsing.
	*/
	@Override
	public NotificationChain basicSetResourceSet(ResourceSet resourceSet, NotificationChain notifications) {
	NotificationChain notificationChain = super.basicSetResourceSet(resourceSet, notifications);
	if (resourceSet != null) {
	String fileExtension = getURI().fileExtension();
	if (fileExtension != null) {
	Object resourceFactory = resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap().get(fileExtension);
	if (resourceFactory == null) {
	ASResourceFactoryRegistry.INSTANCE.configureResourceFactoryRegistry(resourceSet);
	}
	}
	}
	return notificationChain;
	}

	/**
	* @since 1.18
	*/
	protected @NonNull ImmutabilityCheckingAdapter createImmutabilityCheckingAdapter() {
	return new ImmutabilityCheckingAdapter();
	}

	@Override
	protected XMLSave createXMLSave() {
	return new PivotSaveImpl(new XMIHelperImpl(this)
	{
	@Override
	public String getHREF(EObject obj) {
	if (obj instanceof Property) { // Avoid generating a referemce to an EObject that might not exist
	Property asProperty = (Property)obj;
	if (asProperty.isIsImplicit() && (asProperty.getOpposite() != null)) {
	return null;
	}
	}
	return super.getHREF(obj);
	}
	});
	}

	@Override
	protected void doUnload() {
	isUnloading = true;
	try {
	super.doUnload();
	if (lussids != null) {
	resetLUSSIDs();
	}
	}
	finally {
	isUnloading = false;
	}
	}

	@Override
	public @NonNull ASResourceFactory getASResourceFactory() {
	return asResourceFactory;
	}

	@Override
	public @NonNull Map<Object, Object> getDefaultSaveOptions() {
	Map<Object, Object> defaultSaveOptions2 = defaultSaveOptions;
	if (defaultSaveOptions2 == null) {
	defaultSaveOptions = defaultSaveOptions2 = XMIUtil.createPivotSaveOptions();
	}
	return defaultSaveOptions2;
	}

	@SuppressWarnings("deprecation")
	@Override
	protected EObject getEObjectByID(String id) {
	if ((unloadingContents == null) && (idToEObjectMap == null)) { // Lazy xmi:id creation needed by generated ASResources
	AS2ID.assignIds(this, null);
	}
	if (idToEObjectMap == null) {
	return null;
	}
	EObject eObject = idToEObjectMap.get(id);
	if (eObject != null) {
	return eObject;
	}
	if (isLoading()) {
	return null;
	}
	// FIXME Use getXmiidVersion() to select appropriate algorithm
	Map<@NonNull String, @NonNull EObject> legacyXMIId2eObject2 = legacyXMIId2eObject;
	if (legacyXMIId2eObject2 == null) {
	org.eclipse.ocl.pivot.internal.utilities.AS2XMIid as2id = new org.eclipse.ocl.pivot.internal.utilities.AS2XMIid();
	legacyXMIId2eObject = legacyXMIId2eObject2 = new HashMap<>();
	for (EObject eObject2 : new TreeIterable(this)) {
	if (eObject2 instanceof Element) {
	Element element = (Element)eObject2;
	org.eclipse.ocl.pivot.utilities.AS2XMIidVisitor idVisitor = asResourceFactory.createAS2XMIidVisitor(as2id);
	Boolean status = element.accept(idVisitor);
	if (status == Boolean.TRUE) {
	String legacyId = idVisitor.toString();
	if (legacyId != null) {
	legacyXMIId2eObject2.put(legacyId, eObject2);;
	}
	}
	}
	}
	}
	EObject eObject2 = legacyXMIId2eObject2.get(id);
	return eObject2;
	}

	/**
	* @since 1.4
	*/
	@Override
	public @NonNull LUSSIDs getLUSSIDs(@NonNull Map<@NonNull Object, @Nullable Object> options) {
	LUSSIDs lussids2 = lussids;
	if (lussids2 == null) {
	lussids = lussids2 = ((ASResourceFactory.ASResourceFactoryExtension)asResourceFactory).createLUSSIDs(this, options);
	}
	return lussids2;
	}

	@Override
	public @NonNull Model getModel() {
	EList<EObject> contents = getContents();
	if (contents.size() <= 0) {
	throw new IllegalStateException("No Model at root of empty '" + getURI() + "'");
	}
	EObject eObject = contents.get(0);
	if (!(eObject instanceof Model)) {
	throw new IllegalStateException("Non-Model at root of '" + getURI() + "'");
	}
	return (Model)eObject;
	}

	@Override
	public String getURIFragment(EObject eObject) {
	if ((unloadingContents == null) && (idToEObjectMap == null)) {
	AS2ID.assignIds(this, null);
	}
	return super.getURIFragment(eObject);
	}

	/**
	* @since 1.4
	*/
	@Override
	public int getXmiidVersion() {
	for (EObject eRoot : getContents()) {
	if (eRoot instanceof Model) {
	Number xmiidVersion = ((Model)eRoot).getXmiidVersion();
	if (xmiidVersion != null) {
	return xmiidVersion.intValue();
	}
	}
	}
	return 0;
	}

	/**
	* Read the serialized representation to confirm that all external references
	* use an xmi:id to enhance persistence in the case of model evolution.
	*/
	private boolean isFreeOfBadReferences() throws IOException {
	InputStream inputStream = getResourceSet().getURIConverter().createInputStream(uri);
	Reader reader = new InputStreamReader(inputStream);
	StringBuilder s = new StringBuilder();
	char[] buf = new char[4096];
	for (int len; (len = reader.read(buf)) > 0; ) {
	s.append(buf, 0, len);
	}
	reader.close();
	String string = s.toString();
	int index = string.indexOf(";#//@");
	if (index < 0) {
	return true;
	}
	int preIndex = string.lastIndexOf("\n", index);
	int postIndex = string.indexOf("\n", index);
	String refText = string.substring(preIndex, postIndex).trim();
	System.err.println("Missing xmi:id for reference in \'" + uri + "'\n\t" + refText);
	// PivotLUSSIDs.isExternallyReferenceable determines what gets xmi:ids
	return false;
	}

	@Override
	public boolean isOrphanage() {
	return false;
	}

	@Override
	public boolean isSaveable() {
	return isSaveable;
	}

	/**
	* @since 1.4
	*/
	@Override
	public void resetLUSSIDs() {
	LUSSIDs lussids2 = lussids;
	if (lussids2 != null) {
	lussids = null;
	// System.out.println("resetLUSSIDs for " + getURI());
	lussids2.dispose();
	}
	}

	/**
	* Overridden to suppress saving unsaveable content to a probably read-only destination.
	*/
	@Override
	public void save(Map<?, ?> options) throws IOException {
	if (isSaveable) {
	setXmiidVersion(PivotConstants.XMIIDS_CURRENT);
	if (options == null) {
	options = getDefaultSaveOptions();
	}
	XMIUtil.IdResourceEntityHandler.reset(options);
	super.save(options);
	assert SKIP_CHECK_BAD_REFERENCES \|\| isFreeOfBadReferences();
	}
	}

	/**
	* @since 1.5
	*/
	@Override
	public boolean setSaveable(boolean isSaveable) {
	boolean wasSaveable = this.isSaveable;
	this.isSaveable = isSaveable;
	if (isSaveable) {
	if (immutabilityCheckingAdapter != null) {
	this.eAdapters().remove(immutabilityCheckingAdapter);
	for (TreeIterator<EObject> i = getAllProperContents(getContents()); i.hasNext(); ) {
	EObject eObject = i.next();
	eObject.eAdapters().remove(immutabilityCheckingAdapter);
	}
	immutabilityCheckingAdapter = null;
	}
	}
	else if (wasSaveable && CHECK_IMMUTABILITY.isActive()) {
	if (immutabilityCheckingAdapter == null) {
	immutabilityCheckingAdapter = createImmutabilityCheckingAdapter();
	}
	for (TreeIterator<EObject> i = getAllProperContents(getContents()); i.hasNext(); ) {
	EObject eObject = i.next();
	eObject.eAdapters().add(immutabilityCheckingAdapter);
	}
	this.eAdapters().add(immutabilityCheckingAdapter);
	}
	return wasSaveable;
	}

	@Override
	public boolean setUpdating(boolean isUpdating) {
	boolean wasUpdating = this.isUpdating;
	this.isUpdating = isUpdating;
	return wasUpdating;
	}

	/**
	* @since 1.4
	*/
	@Override
	public void setXmiidVersion(int xmiidVersion) {
	for (EObject eRoot : getContents()) {
	if (eRoot instanceof Model) {
	((Model)eRoot).setXmiidVersion(xmiidVersion);
	}
	}
	}

	/**
	* @since 1.18
	*/
	protected String superGetURIFragment(EObject eObject) {
	return super.getURIFragment(eObject); // Bypass assignIds for use by OrphanResource
	}

	@Override
	protected void unloaded(InternalEObject internalEObject) {
	if (internalEObject instanceof PivotObjectImpl) {
	((PivotObjectImpl)internalEObject).unloaded(this);
	}
	super.unloaded(internalEObject);
	}

	@Override
	protected boolean useIDAttributes() {
	return false;
	}

	@Override
	protected boolean useIDs() {
	return true;
	}
	}