Attachment #232445 for bug #351145

View | Details | Raw Unified | Return to bug 351145
Collapse All | Expand All

Lines 1-7 Link Here

(-)src/org/eclipse/sphinx/emf/workspace/loading/ModelLoadManager.java (-9 / +11 lines)
1	/**	1	/**
2	* <copyright>	2	* <copyright>
3	*	3	*
4	* Copyright (c) 2008-2012 BMW Car IT, itemis, See4sys and others.	4	* Copyright (c) 2008-2012 BMW Car IT, itemis, See4sys, Continental Engineering Services (CES) and others.
5	* All rights reserved. This program and the accompanying materials	5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0	6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at	7	* which accompanies this distribution, and is available at
Lines 11-16 Link Here
11	* See4sys - Initial API and implementation	11	* See4sys - Initial API and implementation
12	* BMW Car IT - [374883] Improve handling of out-of-sync workspace files during descriptor initialization	12	* BMW Car IT - [374883] Improve handling of out-of-sync workspace files during descriptor initialization
13	* itemis - [393021] ClassCastExceptions raised during loading model resources with Sphinx are ignored	13	* itemis - [393021] ClassCastExceptions raised during loading model resources with Sphinx are ignored
		14	* CES - Refactoring for a more extensible framework
		15
14	*	16	*
15	* </copyright>	17	* </copyright>
16	*/	18	*/
Lines 51-60 Link Here
51	import org.eclipse.emf.transaction.TransactionalEditingDomain;	53	import org.eclipse.emf.transaction.TransactionalEditingDomain;
52	import org.eclipse.emf.transaction.util.TransactionUtil;	54	import org.eclipse.emf.transaction.util.TransactionUtil;
53	import org.eclipse.osgi.util.NLS;	55	import org.eclipse.osgi.util.NLS;
54	import org.eclipse.sphinx.emf.internal.ecore.proxymanagement.ProxyHelper;	56	import org.eclipse.sphinx.emf.ecore.proxymanagement.IBlackListingIndexer;
		57	import org.eclipse.sphinx.emf.ecore.proxymanagement.ILookupResolver;
		58	import org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper;
55	import org.eclipse.sphinx.emf.internal.ecore.proxymanagement.ProxyHelperAdapterFactory;	59	import org.eclipse.sphinx.emf.internal.ecore.proxymanagement.ProxyHelperAdapterFactory;
56	import org.eclipse.sphinx.emf.internal.ecore.proxymanagement.blacklist.ModelIndex;
57	import org.eclipse.sphinx.emf.internal.ecore.proxymanagement.lookupresolver.EcoreIndex;
58	import org.eclipse.sphinx.emf.internal.resource.ResourceProblemMarkerService;	60	import org.eclipse.sphinx.emf.internal.resource.ResourceProblemMarkerService;
59	import org.eclipse.sphinx.emf.metamodel.IMetaModelDescriptor;	61	import org.eclipse.sphinx.emf.metamodel.IMetaModelDescriptor;
60	import org.eclipse.sphinx.emf.metamodel.MetaModelDescriptorRegistry;	62	import org.eclipse.sphinx.emf.metamodel.MetaModelDescriptorRegistry;
Lines 746-752 Link Here
746	}	748	}
747		749
748	// Disable resolution of fragment-based proxies while model loading is ongoing	750	// Disable resolution of fragment-based proxies while model loading is ongoing
749	ProxyHelper proxyHelper = ProxyHelperAdapterFactory.INSTANCE.adapt(editingDomain.getResourceSet());	751	IProxyHelper proxyHelper = ProxyHelperAdapterFactory.INSTANCE.adapt(editingDomain.getResourceSet());
750	if (proxyHelper != null) {	752	if (proxyHelper != null) {
751	proxyHelper.setIgnoreFragmentBasedProxies(true);	753	proxyHelper.setIgnoreFragmentBasedProxies(true);
752	}	754	}
Lines 805-817 Link Here
805	}	807	}
806	}	808	}
807		809
808	private void updateUnresolvedProxyBlackList(Collection<IFile> files, ModelIndex blackList) {	810	private void updateUnresolvedProxyBlackList(Collection<IFile> files, IBlackListingIndexer iBlackListingIndexer) {
809	Assert.isNotNull(files);	811	Assert.isNotNull(files);
810	Assert.isNotNull(blackList);	812	Assert.isNotNull(iBlackListingIndexer);
811		813
812	for (IFile file : files) {	814	for (IFile file : files) {
813	Resource resource = EcorePlatformUtil.getResource(file);	815	Resource resource = EcorePlatformUtil.getResource(file);
814	blackList.updateIndexOnResourceLoaded(resource);	816	iBlackListingIndexer.updateIndexOnResourceLoaded(resource);
815	}	817	}
816	}	818	}
817		819
Lines 819-825 Link Here
819	* This is a fast implementation of proxy resolution. The idea is to use a map of URI -> EObject to quickly get	821	* This is a fast implementation of proxy resolution. The idea is to use a map of URI -> EObject to quickly get
820	* object.	822	* object.
821	*/	823	*/
822	private void forceProxyResolution(Collection<IFile> files, EcoreIndex lookupResolver, IProgressMonitor monitor) {	824	private void forceProxyResolution(Collection<IFile> files, ILookupResolver lookupResolver, IProgressMonitor monitor) {
823	Assert.isNotNull(files);	825	Assert.isNotNull(files);
824	Assert.isNotNull(lookupResolver);	826	Assert.isNotNull(lookupResolver);
825	SubMonitor progress = SubMonitor.convert(monitor, 100);	827	SubMonitor progress = SubMonitor.convert(monitor, 100);

Lines 22-28 Link Here

(-)META-INF/MANIFEST.MF (-1 lines)
22	org.eclipse.sphinx.emf.internal.ecore;x-internal:=true,	22	org.eclipse.sphinx.emf.internal.ecore;x-internal:=true,
23	org.eclipse.sphinx.emf.internal.ecore.proxymanagement;x-internal:=true,	23	org.eclipse.sphinx.emf.internal.ecore.proxymanagement;x-internal:=true,
24	org.eclipse.sphinx.emf.internal.ecore.proxymanagement.blacklist;x-internal:=true,	24	org.eclipse.sphinx.emf.internal.ecore.proxymanagement.blacklist;x-internal:=true,
25	org.eclipse.sphinx.emf.internal.ecore.proxymanagement.lookupresolver;x-internal:=true,
26	org.eclipse.sphinx.emf.internal.ecore.proxymanagement.resolver;x-internal:=true,	25	org.eclipse.sphinx.emf.internal.ecore.proxymanagement.resolver;x-internal:=true,
27	org.eclipse.sphinx.emf.internal.expressions;x-internal:=true,	26	org.eclipse.sphinx.emf.internal.expressions;x-internal:=true,
28	org.eclipse.sphinx.emf.internal.filesystem;x-internal:=true,	27	org.eclipse.sphinx.emf.internal.filesystem;x-internal:=true,




/**
 * <copyright>
 * 
 * Copyright (c) 2008-2013 See4sys, Continental Engineering Services (CES) 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: 
 *     See4sys - Initial API and implementation
 *     CES - Refactoring for a more extensible framework
 * 
 * </copyright>
 */
package org.eclipse.sphinx.emf.ecore.proxymanagement;

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.jobs.JobChangeAdapter;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.sphinx.emf.internal.ecore.proxymanagement.blacklist.ModelIndex;
import org.eclipse.sphinx.platform.IExtendedPlatformConstants;

/**
 * {@link Adapter}-based implementation of {@link IProxyHelper}. May be used with {@link ResourceSet}s.This is a default
 * and generic implementation. Clients can override this class and provide a more efficient implementation, by taking
 * benefit from the specifics of the used meta-model.
 * 
 * @deprecated Will be removed as soon as a full-fledged model indexing service is in place and can be used to overcome
 *             performance bottlenecks due to proxy resolution.
 */
@Deprecated
public class DefaultProxyHelperAdapter extends AdapterImpl implements IProxyHelper {

	private EcoreIndex fLookupResolver = new EcoreIndex();
	private ModelIndex fBlackList = new ModelIndex();

	private boolean fIgnoreFragmentBasedProxies = false;
	private IgnoreFragmentBasedProxiesFlagResetter fIgnoreFragmentBasedProxiesFlagResetter = new IgnoreFragmentBasedProxiesFlagResetter();

	/*
	 * @see org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper#isIgnoreFragmentBasedProxies()
	 */
	public boolean isIgnoreFragmentBasedProxies() {
		return fIgnoreFragmentBasedProxies;
	}

	/*
	 * @see org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper#setIgnoreFragmentBasedProxies(boolean)
	 */
	public void setIgnoreFragmentBasedProxies(boolean ignore) {
		fIgnoreFragmentBasedProxies = ignore;

		if (ignore) {
			Job.getJobManager().addJobChangeListener(fIgnoreFragmentBasedProxiesFlagResetter);
		} else {
			Job.getJobManager().removeJobChangeListener(fIgnoreFragmentBasedProxiesFlagResetter);
		}
	}

	/*
	 * @see org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper#getLookupResolver()
	 */
	public ILookupResolver getLookupResolver() {
		return fLookupResolver;
	}

	/*
	 * @see org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper#getBlackList()
	 */
	public IBlackListingIndexer getBlackList() {
		return fBlackList;
	}

	/*
	 * @see org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper#dispose()
	 */
	public void dispose() {
		fBlackList.dispose();
	}

	/*
	 * @see org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper#shouldResolve(org.eclipse.emf.ecore.EObject,
	 * org.eclipse.emf.ecore.EObject)
	 */
	public boolean shouldResolve(EObject proxy, EObject context) {
		return true;
	}

	/*
	 * @see
	 * org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper#handleUnresolvedProxy(org.eclipse.emf.ecore.EObject)
	 */
	public void handleUnresolvedProxy(EObject proxy) {

		getBlackList().addProxyURI(((InternalEObject) proxy).eProxyURI());

	}

	/*
	 * @see org.eclipse.emf.common.notify.impl.AdapterImpl#isAdapterForType(java.lang.Object)
	 */
	@Override
	public boolean isAdapterForType(Object type) {
		return type == IProxyHelper.class;
	}

	/*
	 * @see org.eclipse.emf.common.notify.impl.AdapterImpl#setTarget(org.eclipse.emf.common.notify.Notifier)
	 */
	@Override
	public void setTarget(Notifier newTarget) {
		Assert.isLegal(newTarget == null || newTarget instanceof ResourceSet);
		super.setTarget(newTarget);
	}

	protected class IgnoreFragmentBasedProxiesFlagResetter extends JobChangeAdapter {

		private boolean isModelLoadingJob(IJobChangeEvent event) {
			if (event != null) {
				Job job = event.getJob();
				if (job != null) {
					return job.belongsTo(IExtendedPlatformConstants.FAMILY_MODEL_LOADING);
				}
			}
			return false;
		}

		@Override
		public void done(IJobChangeEvent event) {
			if (isModelLoadingJob(event)) {
				// Make sure that resolution of fragment-based proxies gets re-enabled in case that this is the last
				// running model loading job
				if (Job.getJobManager().find(IExtendedPlatformConstants.FAMILY_MODEL_LOADING).length <= 1) {
					setIgnoreFragmentBasedProxies(false);
				}
			}
		}
	}

}




/**
 * <copyright>
 * 
 * Copyright (c) 2008-2013 See4sys, Continental Engineering Services (CES)  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: 
 *     See4sys - Initial API and implementation
 *     CES - Refactoring for a more extensible framework
 * 
 * </copyright>
 */
package org.eclipse.sphinx.emf.ecore.proxymanagement;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.runtime.Assert;
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.osgi.util.NLS;
import org.eclipse.sphinx.platform.messages.PlatformMessages;

/**
 * Simple implementation of Ecore Index (associating fragmend-based URIs with EObjects). Used at the end of model
 * loading operations in order to optimize proxy resolution for performance.
 * 
 * @deprecated Will be removed as soon as a full-fledged model indexing service is in place and can be used to overcome
 *             performance bottlenecks due to proxy resolution.
 */
@Deprecated
public class EcoreIndex implements ILookupResolver {

	// TODO Precise the resource for which we have to maintain this map.
	private Map<String, EObject> index = null;

	/**
	 * 
	 */
	private void assertIsAvailable() {
		if (!isAvailable()) {
			throw new RuntimeException(NLS.bind(PlatformMessages.error_mustNotBeNull, "index")); //$NON-NLS-1$
		}
	}

	/*
	 * @see org.eclipse.sphinx.emf.ecore.proxymanagement.ILookupResolver#isAvailable()
	 */
	public boolean isAvailable() {
		return index != null;
	}

	/*
	 * @see org.eclipse.sphinx.emf.ecore.proxymanagement.ILookupResolver#clear()
	 */
	public void clear() {
		assertIsAvailable();
		index = null;
	}

	private void init() {
		index = new HashMap<String, EObject>();
	}

	/**
	 * Resolves the lookup of an object represented by the given <code>uri</code>, if the lookup-based proxy resolution
	 * <code>isAvailable()</code>.
	 * 
	 * @param uri
	 *            the resource identifier of the object to resolve
	 * @return the object if it was resolved or <code>null</code>, otherwise.
	 */
	private EObject get(URI uri) {
		assertIsAvailable();
		Assert.isNotNull(uri, NLS.bind(PlatformMessages.arg_mustNotBeNull, "uri")); //$NON-NLS-1$
		return index.get(uri.fragment());
	}

	/*
	 * @see org.eclipse.sphinx.emf.ecore.proxymanagement.ILookupResolver#get(org.eclipse.emf.ecore.InternalEObject)
	 */
	public EObject get(EObject proxy) {
		Assert.isNotNull(proxy, NLS.bind(PlatformMessages.arg_mustNotBeNull, "proxy")); //$NON-NLS-1$
		return get(((InternalEObject) proxy).eProxyURI());
	}

	/*
	 * @see org.eclipse.sphinx.emf.ecore.proxymanagement.ILookupResolver#init(java.util.Collection)
	 */
	public void init(Collection<Resource> resources) {
		if (!isAvailable()) {
			init();
		}
		for (Resource resource : resources) {
			for (Iterator<EObject> i = resource.getAllContents(); i.hasNext();) {
				EObject o = i.next();
				String fragment = resource.getURIFragment(o);
				// FIXME A object (from another resource for instance) may already have been put with the same URI.
				index.put(fragment, o);
			}
		}
	}
}




/**
 * <copyright>
 * 
 * Copyright (c) 2013 Continental Engineering Services (CES) 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: 
 *     CES - Initial API and implementation
 * 
 * </copyright>
 */
package org.eclipse.sphinx.emf.ecore.proxymanagement;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;

/**
 * Indexing service used for blacklisting unresolvable proxies. Makes use of a structure where it keeps track of the URI
 * of unresolved proxy objects. It also registers a listener for resource changes and reacts accordingly to resource
 * load/unload by updating also the indexing structure behind.
 */

public interface IBlackListingIndexer {

	/**
	 * Sets whether the blacklisting indexing service should be enabled. Note that before making changes (search, add,
	 * remove proxy URI or update index) on the structure for the indexing service, the service should be enabled.
	 * 
	 * @param enabled
	 *            the state of the indexing service
	 */
	public void setEnabled(boolean enabled);

	/**
	 * Clears the structure on which the indexing service was performed, without removing the listener for resource
	 * changes.
	 */
	public void clearAll();

	/**
	 * Clears the structure on which the indexing was performed and also removes the listener for resource changes.
	 */
	public void dispose();

	/**
	 * Returns whether the given <code>fragmentUri</code> exists in the structure on which the indexing is performed.
	 * 
	 * @param fragmentUri
	 *            the fragment URI to search for
	 * @return <code>true</code>, if the given URI is found; <code>false</code>, otherwise
	 */
	public boolean exists(URI fragmentUri);

	/**
	 * Returns whether the proxy with the given <code>proxyURI</code> exists in the structure on which the indexing is
	 * performed.
	 * 
	 * @param proxyURI
	 *            the proxy URI to search for
	 * @return <code>true</code>, if the given URI is found; <code>false</code>, otherwise
	 */
	public boolean existsProxyURI(URI proxyURI);

	/**
	 * Returns whether the given <code>proxy</code> object exists in the structure on which the indexing is performed.
	 * 
	 * @param proxy
	 *            the proxy object to search for
	 * @return <code>true</code>, if the given object is found; <code>false</code>, otherwise
	 */
	public boolean existsProxy(EObject proxy);

	/**
	 * Adds the the proxy with the given <code>proxyURI</code> in the structure of the indexing service.
	 * 
	 * @param proxyURI
	 *            the given URI to add
	 * @return <code>true</code> if the URI was added; <code>false</code>, if indexing service is not enabled or the URI
	 *         already exists
	 */
	public boolean addProxyURI(URI proxyURI);

	/**
	 * Removes the the proxy with the given <code>proxyURI</code> in the structure of the indexing service.
	 * 
	 * @param proxyURI
	 *            the given URI to add
	 * @return <code>true</code> if the URI was removed; <code>false</code>, if indexing service is not enabled or the
	 *         URI does not exist
	 */
	public boolean removeProxyURI(URI proxyURI);

	/**
	 * Updates the indexing structure, trying to resolve the stored proxy objects against the loaded resource.
	 * 
	 * @param notifier
	 *            the resource that was loaded
	 */
	public void updateIndexOnResourceLoaded(Resource notifier);

	/**
	 * Updates the indexing structure, by removing the stored proxy URIs belonging to the unloaded resource.
	 * 
	 * @param notifier
	 *            the resource that was unloaded
	 */
	public void updateIndexOnResourceUnloaded(Resource notifier);

}




/**
 * <copyright>
 * 
 * Copyright (c) 2013 Continental Engineering Services (CES) 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: 
 *     CES - Initial API and implementation
 * 
 * </copyright>
 */
package org.eclipse.sphinx.emf.ecore.proxymanagement;

import java.util.Collection;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;

/**
 * Performs a lookup of objects inside a collection of resources. It is used at the end of model loading operations in
 * order to optimize proxy resolution for performance.
 */
public interface ILookupResolver {

	/**
	 * Returns whether the lookup-based proxy resolution was initialized and the lookup can be performed. If not, a call
	 * to <code>init</code> is necessary.
	 * 
	 * @return <code>true</code> if the lookup can be performed; <code>false</code> otherwise.
	 */
	public boolean isAvailable();

	/**
	 * Clears the structure on which the lookup-based proxy resolution was performed.
	 */
	public void clear();

	/**
	 * Resolves the lookup of an object represented by the given <code>proxy</code> object, if the lookup-based proxy
	 * resolution <code>isAvailable()</code>.
	 * 
	 * @param proxy
	 *            the proxy representing the object to resolve
	 * @return the object if it was resolved or <code>null</code>, otherwise.
	 */
	public EObject get(EObject proxy);

	/**
	 * Initializes the structure on which to perform the lookup-based proxy resolution, with the given
	 * <code>resources</code>.
	 * 
	 * @param resources
	 *            the collection of resources where the lookup will be performed
	 */
	public void init(Collection<Resource> resources);

}




/**
 * <copyright>
 * 
 * Copyright (c) 2008-2013 See4sys, Continental Engineering Services (CES) 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: 
 *     See4sys - Initial API and implementation
 *     CES - Refactoring for a more extensible framework
 * 
 * </copyright>
 */
package org.eclipse.sphinx.emf.ecore.proxymanagement;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.ResourceSet;

/**
 * A set of {@link ResourceSet} level services which can be used to optimize proxy resolution for performance. Uses a
 * {@link ILookupResolver} to resolve objects and {@link IBlackListingIndexer} for keeping track of the unresolved proxy
 * objects. Clients can take benefit of the particularities of the used meta-model and decide if the attept to resolve a
 * proxy object should be made and also how to handle an unresolved proxy.
 */
public interface IProxyHelper {

	/**
	 * Returns whether the fragment-based proxies are ignored at proxy resolution.
	 * 
	 * @return <code>true</code>, if fragment-based proxiesa are ignored; <code>false</code>, otherwise.
	 */
	boolean isIgnoreFragmentBasedProxies();

	/**
	 * Sets the flag indicating if the fragment-based proxies are ignored at proxy resolution.
	 * 
	 * @param ignoreFragmentBasedProxies
	 *            whether to ignore fragment-based proxies
	 */
	void setIgnoreFragmentBasedProxies(boolean ignoreFragmentBasedProxies);

	/**
	 * Returns the lookup resolver that performs a lookup of objects.
	 * 
	 * @return the lookup resolver
	 */
	ILookupResolver getLookupResolver();

	/**
	 * Returns the indexing service used for unresolvable proxies.
	 * 
	 * @return
	 */
	IBlackListingIndexer getBlackList();

	/**
	 * Performs all the needed dispose operations.
	 */
	void dispose();

	/**
	 * Returns whether to try to resolve the given <code>proxy</code> object, in the given <code>context</code> object.
	 * The proxy resolution operation is time-consuming, because the attemt to resolve the object is performed inside
	 * the entire resource set. This is the last change for clients of this method to abort it, if it is not necessary
	 * to perform it at this point.
	 * 
	 * @param proxy
	 *            the EObject containing the URI of the EObject to resolve scopeContext
	 * @param context
	 *            the EObject used to calculate the set of EObjects from which to resolve the specified proxy
	 * @return <code>true</code>, if the attempt to resolve the object is performed; <code>false</code>, if the object
	 *         remains unresolved.
	 */
	boolean shouldResolve(EObject proxy, EObject context);

	/**
	 * Performs the necessary operations for handling an unresolved proxy.
	 * 
	 * @param proxy
	 *            the unresolved proxy object
	 */
	void handleUnresolvedProxy(EObject proxy);

}




/**
 * <copyright>
 *
 * Copyright (c) 2013 itemis, Continental Engineering Services (CES) 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

 * Contributors:
 *     itemis - Initial API and implementation
 *     itemis - [409458] Enhance ScopingResourceSetImpl#getEObjectInScope() to enable cross-document references between model files with different metamodels
 *     CES - Refactoring for a more extensible framework
 *
 * </copyright>
 */

import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.sphinx.emf.internal.ecore.proxymanagement.ProxyHelper;
import org.eclipse.sphinx.emf.internal.ecore.proxymanagement.ProxyHelperAdapterFactory;
import org.eclipse.sphinx.emf.internal.ecore.proxymanagement.resolver.DefaultResourceSetEObjectResolver;
import org.eclipse.sphinx.emf.internal.ecore.proxymanagement.resolver.EObjectResolveRequest;

import org.eclipse.sphinx.emf.metamodel.IMetaModelDescriptor;
import org.eclipse.sphinx.emf.metamodel.MetaModelDescriptorRegistry;

/**
 * Handles the proxy resolution by trying to resolve a proxy object inside a resource set. Uses a {@link IProxyHelper}
 * in order to resolve proxies in a performance-optimized way.
 */
public class ProxyResolutionBehavior {

	/**

	private IEObjectResolver fEObjectResolver;

	/**
	 * Protected constructor for the singleton pattern.
	 */
	protected ProxyResolutionBehavior(IEObjectResolver eObjectResolver) {
		fEObjectResolver = eObjectResolver;
	}

	/**
	 * Resolves the given proxy object inside the given context, by performing the proxy resolution in the resource set
	 * containing the resource where the context object is located.
	 * 
	 * @param contextObject
	 *            the context within the proxy resolution is performed
	 * @param proxy
	 *            the object to resolve
	 * @return the resolved object, if the resolution was successful or the original <code>proxy</code> object, if it
	 *         was not possible to resolve it.
	 */
	public EObject eResolveProxy(EObject contextObject, EObject proxy) {
		if (proxy == null) {
			return null;

		return EcoreUtil.resolve(proxy, contextObject);
	}

	/**
	 * Returns whether the given object is a proxy or not.
	 * 
	 * @param proxy
	 *            the given object that may or may not be a proxy
	 * @return <code>true</code> if <code>proxy</code> is a proxy object, or <code>false</code>, otherwise.
	 */
	protected boolean isNoProxy(EObject proxy) {
		return ((InternalEObject) proxy).eProxyURI() == null;
	}

	/**
	 * Resolves the given proxy object inside the given context, by using a proxy helper registered for the given
	 * resource set.
	 * 
	 * @param resourceSet
	 *            the resource set for which to retrieve the proxy helper
	 * @param contextObject
	 *            the object which is to be used to calculate the set of EObjects from which to resolve the specified
	 *            <code>proxy</code>.
	 * @param proxy
	 *            the object to resolve
	 * @return the resolved object, if the resolution was successful or the original <code>proxy</code> object, if it
	 *         was not possible to resolve it.
	 */
	protected EObject eResolveProxyInResourceSet(ResourceSet resourceSet, EObject contextObject, EObject proxy) {
		Assert.isNotNull(resourceSet);
		Assert.isNotNull(proxy);

		URI proxyURI = ((InternalEObject) proxy).eProxyURI();

		// Retrieve proxy helper in order to resolve proxy in a performance-optimized way
		IProxyHelper proxyHelper = ProxyHelperAdapterFactory.INSTANCE.adapt(resourceSet);
		if (proxyHelper != null) {
			// If proxy URI references a known unresolved proxy then don't try to resolve it again
			if (proxyHelper.getBlackList().existsProxy(proxy)) {
				return proxy;
			}


			if (proxyURI.segmentCount() == 0) {
				// If lookup-based proxy resolution is possible then go ahead and try to do so
				if (proxyURI.segmentCount() == 0 && proxyHelper.getLookupResolver().isAvailable()) {
					EObject resolvedEObject = proxyHelper.getLookupResolver().get(proxy);
					if (resolvedEObject != null) {
						return resolvedEObject;
					}

				}
			}
		}
		if (proxyHelper.shouldResolve(proxy, contextObject)) {
			EObjectResolveRequest resolveRequest = new EObjectResolveRequest(proxy, contextObject);
			resolveRequest.setIncludeUnloadedEObjects(true);
			EObject resolvedEObject = fEObjectResolver.resolve(resolveRequest);

			if (resolvedEObject == proxy && proxyHelper != null) {
				// Remember proxy as known unresolved proxy
				/*
				 * !! Important Note !! Blacklist proxy only if it has the same metamodel or target metamodel as the
				 * object that references it. When the target object for the proxy of some other metamodel becomes
				 * available it will get loaded into the editing domain/resource set for this other metamodel but not
				 * into the same editing domain/resource set that contains the object referencing the proxy. Therefore
				 * the proxy must also be blacklisted only by the proxy helper adapter of the other resource set but not
				 * by the proxy helper adapter of this resource set.
				 */
				IMetaModelDescriptor proxyMMDescriptor = MetaModelDescriptorRegistry.INSTANCE.getDescriptor(proxy.eClass());
				IMetaModelDescriptor contextMMDescriptor = MetaModelDescriptorRegistry.INSTANCE.getEffectiveDescriptor(contextObject.eResource());
				if (proxyMMDescriptor.equals(contextMMDescriptor)) {
					proxyHelper.handleUnresolvedProxy(proxy);
				}
			}

			return resolvedEObject;
		}

		return proxy;
	}
}




/**
 * <copyright>
 * 
 * Copyright (c) 2008-2012 See4sys, BMW Car IT, Continental Engineering Services (CES) 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

 * Contributors: 
 *     See4sys - Initial API and implementation
 *     BMW Car IT - Avoid usage of Object.finalize
 *     CES - Refactoring for a more extensible framework
 * 
 * </copyright>
 */


import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
import org.eclipse.emf.ecore.resource.ResourceSet;

import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.sphinx.emf.domain.factory.EditingDomainFactoryListenerRegistry;
import org.eclipse.sphinx.emf.domain.factory.ITransactionalEditingDomainFactoryListener;
import org.eclipse.sphinx.emf.ecore.proxymanagement.DefaultProxyHelperAdapter;
import org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper;
import org.eclipse.sphinx.emf.metamodel.MetaModelDescriptorRegistry;

/**
 * An {@link AdapterFactory adapter factory} for creating {@link IProxyHelper} adapters on {@link ResourceSet}s.
 * 
 * @deprecated Will be removed as soon as a full-fledged model indexing service is in place and can be used to overcome
 *             performance bottlenecks due to proxy resolution.
 */
@Deprecated
public class ProxyHelperAdapterFactory extends AdapterFactoryImpl implements ITransactionalEditingDomainFactoryListener {

	/**

	 */
	@Override
	public boolean isFactoryForType(Object type) {
		return type == IProxyHelper.class;
	}

	/**
	 * Returns either a previously associated {@link IProxyHelper} adapter or a newly associated one, as appropriate.
	 * {@link Adapter#isAdapterForType(Object) Checks} if the an adapter for {@link IProxyHelper} is already associated
	 * with the target and returns it in that case; {@link AdapterFactory#adaptNew(Notifier, Object) creates} a new
	 * {@link IProxyHelper} adapter if possible otherwise.
	 * 
	 * @param target
	 *            The notifier to adapt.
	 * @return A previously existing associated {@link IProxyHelper} adapter, a new associated {@link IProxyHelper}
	 *         adapter if possible, or <code>null</code> otherwise.
	 * @see AdapterFactory#adapt(Notifier, Object)
	 * @see Adapter#isAdapterForType(Object)
	 * @see AdapterFactory#adaptNew(Notifier, Object)
	 */
	public IProxyHelper adapt(Notifier target) {
		if (target != null) {
			return (IProxyHelper) adapt(target, IProxyHelper.class);
		}
		return null;
	}

	@Override
	protected Adapter createAdapter(Notifier target) {
		if (target instanceof ResourceSet) {
			return new DefaultProxyHelperAdapter();
		}
		return null;
	}

	 * eclipse .emf.transaction.TransactionalEditingDomain)
	 */
	public void preDisposeEditingDomain(TransactionalEditingDomain editingDomain) {
		Adapter adapter = EcoreUtil.getExistingAdapter(editingDomain.getResourceSet(), IProxyHelper.class);
		if (adapter instanceof IProxyHelper) {
			((IProxyHelper) adapter).dispose();
		}
	}
}

Lines 9-14 Link Here

(-)src/org/eclipse/sphinx/emf/internal/ecore/proxymanagement/blacklist/ModelIndex.java (-1 / +66 lines)
9	*	9	*
10	* Contributors:	10	* Contributors:
11	* See4sys - Initial API and implementation	11	* See4sys - Initial API and implementation
		12	* Continental - Refactoring for a more extensible framework
12	*	13	*
13	* </copyright>	14	* </copyright>
14	*/	15	*/
Lines 18-27 Link Here
18	import java.util.Collections;	19	import java.util.Collections;
19		20
20	import org.eclipse.core.resources.IProject;	21	import org.eclipse.core.resources.IProject;
		22	import org.eclipse.core.runtime.Assert;
21	import org.eclipse.emf.common.util.URI;	23	import org.eclipse.emf.common.util.URI;
22	import org.eclipse.emf.ecore.EClass;	24	import org.eclipse.emf.ecore.EClass;
23	import org.eclipse.emf.ecore.EObject;	25	import org.eclipse.emf.ecore.EObject;
		26	import org.eclipse.emf.ecore.InternalEObject;
24	import org.eclipse.emf.ecore.resource.Resource;	27	import org.eclipse.emf.ecore.resource.Resource;
		28	import org.eclipse.osgi.util.NLS;
		29	import org.eclipse.sphinx.emf.ecore.proxymanagement.IBlackListingIndexer;
		30	import org.eclipse.sphinx.platform.messages.PlatformMessages;
25		31
26	/**	32	/**
27	* Indexing service used for blacklisting unresolvable proxies. Used to avoid repeated attempts to resolve such proxies	33	* Indexing service used for blacklisting unresolvable proxies. Used to avoid repeated attempts to resolve such proxies
Lines 31-60 Link Here
31	* performance bottlenecks due to proxy resolution.	37	* performance bottlenecks due to proxy resolution.
32	*/	38	*/
33	@Deprecated	39	@Deprecated
34	public class ModelIndex {	40	public class ModelIndex implements IBlackListingIndexer {
35		41
36	private MapModelIndex mapModelIndex;	42	private MapModelIndex mapModelIndex;
37	private boolean enabled;	43	private boolean enabled;
38		44
		45	/*
		46	* @see org.eclipse.sphinx.emf.ecore.proxymanagement.IBlackListingIndexer#setEnabled(boolean)
		47	*/
39	public void setEnabled(boolean enabled) {	48	public void setEnabled(boolean enabled) {
40	this.enabled = enabled;	49	this.enabled = enabled;
41	}	50	}
42		51
		52	/**
		53	*
		54	*/
43	public ModelIndex() {	55	public ModelIndex() {
44	mapModelIndex = new MapModelIndex();	56	mapModelIndex = new MapModelIndex();
45	enabled = true;	57	enabled = true;
46	}	58	}
47		59
		60	/*
		61	* @see org.eclipse.sphinx.emf.ecore.proxymanagement.IBlackListingIndexer#clearAll()
		62	*/
48	public void clearAll() {	63	public void clearAll() {
49	if (enabled) {	64	if (enabled) {
50	mapModelIndex.clearAll();	65	mapModelIndex.clearAll();
51	}	66	}
52	}	67	}
53		68
		69	/*
		70	* @see org.eclipse.sphinx.emf.ecore.proxymanagement.IBlackListingIndexer#dispose()
		71	*/
54	public void dispose() {	72	public void dispose() {
55	mapModelIndex.dispose();	73	mapModelIndex.dispose();
56	}	74	}
57		75
		76	/*
		77	* @see org.eclipse.sphinx.emf.ecore.proxymanagement.IBlackListingIndexer#exists(org.eclipse.emf.common.util.URI)
		78	*/
58	public boolean exists(URI fragmentUri) {	79	public boolean exists(URI fragmentUri) {
59	if (enabled) {	80	if (enabled) {
60	return mapModelIndex.exists(fragmentUri);	81	return mapModelIndex.exists(fragmentUri);
Lines 62-67 Link Here
62	return false;	83	return false;
63	}	84	}
64		85
		86	/*
		87	* @see
		88	* org.eclipse.sphinx.emf.ecore.proxymanagement.IBlackListingIndexer#existsProxyURI(org.eclipse.emf.common.util.URI)
		89	*/
65	public boolean existsProxyURI(URI proxyURI) {	90	public boolean existsProxyURI(URI proxyURI) {
66	if (enabled) {	91	if (enabled) {
67	return mapModelIndex.existsProxyURI(proxyURI);	92	return mapModelIndex.existsProxyURI(proxyURI);
Lines 69-74 Link Here
69	return false;	94	return false;
70	}	95	}
71		96
		97	/*
		98	* @see org.eclipse.sphinx.emf.ecore.proxymanagement.IBlackListingIndexer#existsProxy(org.eclipse.emf.ecore.EObject)
		99	*/
		100	public boolean existsProxy(EObject proxy) {
		101	Assert.isNotNull(proxy, NLS.bind(PlatformMessages.arg_mustNotBeNull, "proxy")); //$NON-NLS-1$
		102	return existsProxyURI(((InternalEObject) proxy).eProxyURI());
		103
		104	}
		105
		106	/*
		107	* @see
		108	* org.eclipse.sphinx.emf.ecore.proxymanagement.IBlackListingIndexer#addProxyURI(org.eclipse.emf.common.util.URI)
		109	*/
72	public boolean addProxyURI(URI proxyURI) {	110	public boolean addProxyURI(URI proxyURI) {
73	if (enabled) {	111	if (enabled) {
74	return mapModelIndex.addProxyURI(proxyURI);	112	return mapModelIndex.addProxyURI(proxyURI);
Lines 76-81 Link Here
76	return false;	114	return false;
77	}	115	}
78		116
		117	/*
		118	* @see
		119	* org.eclipse.sphinx.emf.ecore.proxymanagement.IBlackListingIndexer#removeProxyURI(org.eclipse.emf.common.util.URI)
		120	*/
79	public boolean removeProxyURI(URI proxyURI) {	121	public boolean removeProxyURI(URI proxyURI) {
80	if (enabled) {	122	if (enabled) {
81	return mapModelIndex.removeProxyURI(proxyURI);	123	return mapModelIndex.removeProxyURI(proxyURI);
Lines 83-100 Link Here
83	return false;	125	return false;
84	}	126	}
85		127
		128	/*
		129	* @see
		130	* org.eclipse.sphinx.emf.ecore.proxymanagement.IBlackListingIndexer#updateIndexOnResourceLoaded(org.eclipse.emf
		131	* .ecore.resource.Resource)
		132	*/
86	public void updateIndexOnResourceLoaded(Resource notifier) {	133	public void updateIndexOnResourceLoaded(Resource notifier) {
87	if (enabled) {	134	if (enabled) {
88	mapModelIndex.updateIndexOnResourceLoaded(notifier);	135	mapModelIndex.updateIndexOnResourceLoaded(notifier);
89	}	136	}
90	}	137	}
91		138
		139	/*
		140	* @see
		141	* org.eclipse.sphinx.emf.ecore.proxymanagement.IBlackListingIndexer#updateIndexOnResourceUnloaded(org.eclipse.emf
		142	* .ecore.resource.Resource)
		143	*/
92	public void updateIndexOnResourceUnloaded(Resource notifier) {	144	public void updateIndexOnResourceUnloaded(Resource notifier) {
93	if (enabled) {	145	if (enabled) {
94	mapModelIndex.updateIndexOnResourceUnloaded(notifier);	146	mapModelIndex.updateIndexOnResourceUnloaded(notifier);
95	}	147	}
96	}	148	}
97		149
		150	/**
		151	* @param eClass
		152	* @param scope
		153	* @return
		154	*/
98	public Collection<URI> findInstances(EClass eClass, IProject scope) {	155	public Collection<URI> findInstances(EClass eClass, IProject scope) {
99	if (enabled) {	156	if (enabled) {
100	return mapModelIndex.findInstances(eClass, scope);	157	return mapModelIndex.findInstances(eClass, scope);
Lines 102-107 Link Here
102	return Collections.emptySet();	159	return Collections.emptySet();
103	}	160	}
104		161
		162	/**
		163	* @param object
		164	* @param scope
		165	* @return
		166	*/
105	public Collection<URI> findReferencesTo(EObject object, IProject scope) {	167	public Collection<URI> findReferencesTo(EObject object, IProject scope) {
106	if (enabled) {	168	if (enabled) {
107	return mapModelIndex.findReferencesTo(object, scope);	169	return mapModelIndex.findReferencesTo(object, scope);
Lines 109-114 Link Here
109	return Collections.emptySet();	171	return Collections.emptySet();
110	}	172	}
111		173
		174	/**
		175	* @throws Exception
		176	*/
112	public void reIndex() throws Exception {	177	public void reIndex() throws Exception {
113	if (enabled) {	178	if (enabled) {
114	mapModelIndex.reIndex();	179	mapModelIndex.reIndex();




import org.eclipse.emf.transaction.ResourceSetListenerImpl;
import org.eclipse.sphinx.emf.Activator;
import org.eclipse.sphinx.emf.domain.factory.AbstractResourceSetListenerInstaller;
import org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper;
import org.eclipse.sphinx.emf.internal.ecore.proxymanagement.ProxyHelperAdapterFactory;
import org.eclipse.sphinx.emf.model.IModelDescriptor;
import org.eclipse.sphinx.emf.model.ModelDescriptorRegistry;


	@Override
	public void resourceSetChanged(ResourceSetChangeEvent event) {
		IProxyHelper proxyHelper = ProxyHelperAdapterFactory.INSTANCE.adapt(event.getEditingDomain().getResourceSet());
		List<?> notifications = event.getNotifications();
		for (Object object : notifications) {
			if (object instanceof Notification) {

						}
						for (Resource resource : updatedResources) {
							if (resource.isLoaded()) {
								IProxyHelper proxyHelper = ProxyHelperAdapterFactory.INSTANCE.adapt(resource.getResourceSet());
								proxyHelper.getBlackList().updateIndexOnResourceLoaded(resource);
							}
						}

Return to bug 351145

Added Link Here

(-)src/org/eclipse/sphinx/emf/ecore/proxymanagement/DefaultProxyHelperAdapter.java (+148 lines)
1	/**
2	* <copyright>
3	*
4	* Copyright (c) 2008-2013 See4sys, Continental Engineering Services (CES) and others.
5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at
8	* http://www.eclipse.org/legal/epl-v10.html
9	*
10	* Contributors:
11	* See4sys - Initial API and implementation
12	* CES - Refactoring for a more extensible framework
13	*
14	* </copyright>
15	*/
16	package org.eclipse.sphinx.emf.ecore.proxymanagement;
17
18	import org.eclipse.core.runtime.Assert;
19	import org.eclipse.core.runtime.jobs.IJobChangeEvent;
20	import org.eclipse.core.runtime.jobs.Job;
21	import org.eclipse.core.runtime.jobs.JobChangeAdapter;
22	import org.eclipse.emf.common.notify.Adapter;
23	import org.eclipse.emf.common.notify.Notifier;
24	import org.eclipse.emf.common.notify.impl.AdapterImpl;
25	import org.eclipse.emf.ecore.EObject;
26	import org.eclipse.emf.ecore.InternalEObject;
27	import org.eclipse.emf.ecore.resource.ResourceSet;
28	import org.eclipse.sphinx.emf.internal.ecore.proxymanagement.blacklist.ModelIndex;
29	import org.eclipse.sphinx.platform.IExtendedPlatformConstants;
30
31	/**
32	* {@link Adapter}-based implementation of {@link IProxyHelper}. May be used with {@link ResourceSet}s.This is a default
33	* and generic implementation. Clients can override this class and provide a more efficient implementation, by taking
34	* benefit from the specifics of the used meta-model.
35	*
36	* @deprecated Will be removed as soon as a full-fledged model indexing service is in place and can be used to overcome
37	* performance bottlenecks due to proxy resolution.
38	*/
39	@Deprecated
40	public class DefaultProxyHelperAdapter extends AdapterImpl implements IProxyHelper {
41
42	private EcoreIndex fLookupResolver = new EcoreIndex();
43	private ModelIndex fBlackList = new ModelIndex();
44
45	private boolean fIgnoreFragmentBasedProxies = false;
46	private IgnoreFragmentBasedProxiesFlagResetter fIgnoreFragmentBasedProxiesFlagResetter = new IgnoreFragmentBasedProxiesFlagResetter();
47
48	/*
49	* @see org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper#isIgnoreFragmentBasedProxies()
50	*/
51	public boolean isIgnoreFragmentBasedProxies() {
52	return fIgnoreFragmentBasedProxies;
53	}
54
55	/*
56	* @see org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper#setIgnoreFragmentBasedProxies(boolean)
57	*/
58	public void setIgnoreFragmentBasedProxies(boolean ignore) {
59	fIgnoreFragmentBasedProxies = ignore;
60
61	if (ignore) {
62	Job.getJobManager().addJobChangeListener(fIgnoreFragmentBasedProxiesFlagResetter);
63	} else {
64	Job.getJobManager().removeJobChangeListener(fIgnoreFragmentBasedProxiesFlagResetter);
65	}
66	}
67
68	/*
69	* @see org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper#getLookupResolver()
70	*/
71	public ILookupResolver getLookupResolver() {
72	return fLookupResolver;
73	}
74
75	/*
76	* @see org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper#getBlackList()
77	*/
78	public IBlackListingIndexer getBlackList() {
79	return fBlackList;
80	}
81
82	/*
83	* @see org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper#dispose()
84	*/
85	public void dispose() {
86	fBlackList.dispose();
87	}
88
89	/*
90	* @see org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper#shouldResolve(org.eclipse.emf.ecore.EObject,
91	* org.eclipse.emf.ecore.EObject)
92	*/
93	public boolean shouldResolve(EObject proxy, EObject context) {
94	return true;
95	}
96
97	/*
98	* @see
99	* org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper#handleUnresolvedProxy(org.eclipse.emf.ecore.EObject)
100	*/
101	public void handleUnresolvedProxy(EObject proxy) {
102
103	getBlackList().addProxyURI(((InternalEObject) proxy).eProxyURI());
104
105	}
106
107	/*
108	* @see org.eclipse.emf.common.notify.impl.AdapterImpl#isAdapterForType(java.lang.Object)
109	*/
110	@Override
111	public boolean isAdapterForType(Object type) {
112	return type == IProxyHelper.class;
113	}
114
115	/*
116	* @see org.eclipse.emf.common.notify.impl.AdapterImpl#setTarget(org.eclipse.emf.common.notify.Notifier)
117	*/
118	@Override
119	public void setTarget(Notifier newTarget) {
120	Assert.isLegal(newTarget == null \|\| newTarget instanceof ResourceSet);
121	super.setTarget(newTarget);
122	}
123
124	protected class IgnoreFragmentBasedProxiesFlagResetter extends JobChangeAdapter {
125
126	private boolean isModelLoadingJob(IJobChangeEvent event) {
127	if (event != null) {
128	Job job = event.getJob();
129	if (job != null) {
130	return job.belongsTo(IExtendedPlatformConstants.FAMILY_MODEL_LOADING);
131	}
132	}
133	return false;
134	}
135
136	@Override
137	public void done(IJobChangeEvent event) {
138	if (isModelLoadingJob(event)) {
139	// Make sure that resolution of fragment-based proxies gets re-enabled in case that this is the last
140	// running model loading job
141	if (Job.getJobManager().find(IExtendedPlatformConstants.FAMILY_MODEL_LOADING).length <= 1) {
142	setIgnoreFragmentBasedProxies(false);
143	}
144	}
145	}
146	}
147
148	}

Added Link Here

(-)src/org/eclipse/sphinx/emf/ecore/proxymanagement/IBlackListingIndexer.java (+113 lines)
1	/**
2	* <copyright>
3	*
4	* Copyright (c) 2013 Continental Engineering Services (CES) and others.
5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at
8	* http://www.eclipse.org/legal/epl-v10.html
9	*
10	* Contributors:
11	* CES - Initial API and implementation
12	*
13	* </copyright>
14	*/
15	package org.eclipse.sphinx.emf.ecore.proxymanagement;
16
17	import org.eclipse.emf.common.util.URI;
18	import org.eclipse.emf.ecore.EObject;
19	import org.eclipse.emf.ecore.resource.Resource;
20
21	/**
22	* Indexing service used for blacklisting unresolvable proxies. Makes use of a structure where it keeps track of the URI
23	* of unresolved proxy objects. It also registers a listener for resource changes and reacts accordingly to resource
24	* load/unload by updating also the indexing structure behind.
25	*/
26
27	public interface IBlackListingIndexer {
28
29	/**
30	* Sets whether the blacklisting indexing service should be enabled. Note that before making changes (search, add,
31	* remove proxy URI or update index) on the structure for the indexing service, the service should be enabled.
32	*
33	* @param enabled
34	* the state of the indexing service
35	*/
36	public void setEnabled(boolean enabled);
37
38	/**
39	* Clears the structure on which the indexing service was performed, without removing the listener for resource
40	* changes.
41	*/
42	public void clearAll();
43
44	/**
45	* Clears the structure on which the indexing was performed and also removes the listener for resource changes.
46	*/
47	public void dispose();
48
49	/**
50	* Returns whether the given <code>fragmentUri</code> exists in the structure on which the indexing is performed.
51	*
52	* @param fragmentUri
53	* the fragment URI to search for
54	* @return <code>true</code>, if the given URI is found; <code>false</code>, otherwise
55	*/
56	public boolean exists(URI fragmentUri);
57
58	/**
59	* Returns whether the proxy with the given <code>proxyURI</code> exists in the structure on which the indexing is
60	* performed.
61	*
62	* @param proxyURI
63	* the proxy URI to search for
64	* @return <code>true</code>, if the given URI is found; <code>false</code>, otherwise
65	*/
66	public boolean existsProxyURI(URI proxyURI);
67
68	/**
69	* Returns whether the given <code>proxy</code> object exists in the structure on which the indexing is performed.
70	*
71	* @param proxy
72	* the proxy object to search for
73	* @return <code>true</code>, if the given object is found; <code>false</code>, otherwise
74	*/
75	public boolean existsProxy(EObject proxy);
76
77	/**
78	* Adds the the proxy with the given <code>proxyURI</code> in the structure of the indexing service.
79	*
80	* @param proxyURI
81	* the given URI to add
82	* @return <code>true</code> if the URI was added; <code>false</code>, if indexing service is not enabled or the URI
83	* already exists
84	*/
85	public boolean addProxyURI(URI proxyURI);
86
87	/**
88	* Removes the the proxy with the given <code>proxyURI</code> in the structure of the indexing service.
89	*
90	* @param proxyURI
91	* the given URI to add
92	* @return <code>true</code> if the URI was removed; <code>false</code>, if indexing service is not enabled or the
93	* URI does not exist
94	*/
95	public boolean removeProxyURI(URI proxyURI);
96
97	/**
98	* Updates the indexing structure, trying to resolve the stored proxy objects against the loaded resource.
99	*
100	* @param notifier
101	* the resource that was loaded
102	*/
103	public void updateIndexOnResourceLoaded(Resource notifier);
104
105	/**
106	* Updates the indexing structure, by removing the stored proxy URIs belonging to the unloaded resource.
107	*
108	* @param notifier
109	* the resource that was unloaded
110	*/
111	public void updateIndexOnResourceUnloaded(Resource notifier);
112
113	}

Lines 40-46 Link Here

(-)src/org/eclipse/sphinx/emf/internal/ecore/proxymanagement/blacklist/ModelIndexUpdater.java (-3 / +3 lines)
40	import org.eclipse.emf.transaction.ResourceSetListenerImpl;	40	import org.eclipse.emf.transaction.ResourceSetListenerImpl;
41	import org.eclipse.sphinx.emf.Activator;	41	import org.eclipse.sphinx.emf.Activator;
42	import org.eclipse.sphinx.emf.domain.factory.AbstractResourceSetListenerInstaller;	42	import org.eclipse.sphinx.emf.domain.factory.AbstractResourceSetListenerInstaller;
43	import org.eclipse.sphinx.emf.internal.ecore.proxymanagement.ProxyHelper;	43	import org.eclipse.sphinx.emf.ecore.proxymanagement.IProxyHelper;
44	import org.eclipse.sphinx.emf.internal.ecore.proxymanagement.ProxyHelperAdapterFactory;	44	import org.eclipse.sphinx.emf.internal.ecore.proxymanagement.ProxyHelperAdapterFactory;
45	import org.eclipse.sphinx.emf.model.IModelDescriptor;	45	import org.eclipse.sphinx.emf.model.IModelDescriptor;
46	import org.eclipse.sphinx.emf.model.ModelDescriptorRegistry;	46	import org.eclipse.sphinx.emf.model.ModelDescriptorRegistry;
Lines 70-76 Link Here
70		70
71	@Override	71	@Override
72	public void resourceSetChanged(ResourceSetChangeEvent event) {	72	public void resourceSetChanged(ResourceSetChangeEvent event) {
73	ProxyHelper proxyHelper = ProxyHelperAdapterFactory.INSTANCE.adapt(event.getEditingDomain().getResourceSet());	73	IProxyHelper proxyHelper = ProxyHelperAdapterFactory.INSTANCE.adapt(event.getEditingDomain().getResourceSet());
74	List<?> notifications = event.getNotifications();	74	List<?> notifications = event.getNotifications();
75	for (Object object : notifications) {	75	for (Object object : notifications) {
76	if (object instanceof Notification) {	76	if (object instanceof Notification) {
Lines 142-148 Link Here
142	}	142	}
143	for (Resource resource : updatedResources) {	143	for (Resource resource : updatedResources) {
144	if (resource.isLoaded()) {	144	if (resource.isLoaded()) {
145	ProxyHelper proxyHelper = ProxyHelperAdapterFactory.INSTANCE.adapt(resource.getResourceSet());	145	IProxyHelper proxyHelper = ProxyHelperAdapterFactory.INSTANCE.adapt(resource.getResourceSet());
146	proxyHelper.getBlackList().updateIndexOnResourceLoaded(resource);	146	proxyHelper.getBlackList().updateIndexOnResourceLoaded(resource);
147	}	147	}
148	}	148	}