Attachment #140694 for bug #282269

Lines 55-60 Link Here

(-)plugin.xml (+1 lines)
55	<extension-point id="artifactedit" name="Component Artifact Edit" schema="schema/artifactedit.exsd"/>	55	<extension-point id="artifactedit" name="Component Artifact Edit" schema="schema/artifactedit.exsd"/>
56	<extension-point id="componentimpl" name="componentimpl" schema="schema/componentimpl.exsd"/>	56	<extension-point id="componentimpl" name="componentimpl" schema="schema/componentimpl.exsd"/>
57	<extension-point id="resourceFactories" name="Resource Factory Association (Internal)" schema="schema/resourceFactories.exsd"/>	57	<extension-point id="resourceFactories" name="Resource Factory Association (Internal)" schema="schema/resourceFactories.exsd"/>
		58	<extension-point id="referenceResolver" name="referenceResolver" schema="schema/referenceResolver.exsd"/>
58		59
59	<!-- Contribute a URIResolverExtension for flexible projects -->	60	<!-- Contribute a URIResolverExtension for flexible projects -->
60	<extension point="org.eclipse.wst.common.uriresolver.resolverExtensions">	61	<extension point="org.eclipse.wst.common.uriresolver.resolverExtensions">




import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.wst.common.componentcore.internal.ComponentcorePackage;
import org.eclipse.wst.common.componentcore.internal.DependencyType;
import org.eclipse.wst.common.componentcore.internal.ReferencedComponent;
import org.eclipse.wst.common.componentcore.internal.StructureEdit;
import org.eclipse.wst.common.componentcore.internal.WorkbenchComponent;
import org.eclipse.wst.common.componentcore.resolvers.IReferenceResolver;
import org.eclipse.wst.common.componentcore.resolvers.ReferenceResolverUtil;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;


			core = StructureEdit.getStructureEditForWrite(enclosingComponent.getProject());
			WorkbenchComponent component = core.getComponent();
			List referencedComponents = component.getReferencedComponents();
			IReferenceResolver resolver = ReferenceResolverUtil.getDefault().getResolver(this);
			ReferencedComponent refComp = resolver.resolve(this);
				refComp.setHandle(ModuleURIUtil.fullyQualifyURI(referencedComponent.getProject()));
			else
				refComp.setHandle(ModuleURIUtil.archiveComponentfullyQualifyURI(referencedComponent.getName())); 
			refComp.setRuntimePath(runtimePath);
			refComp.setDependencyType(DependencyType.get(dependencyType));
			refComp.setArchiveName(archiveName);
			if(!referencedComponents.contains(refComp)){
				referencedComponents.add(refComp);
			}

			ReferencedComponent actualReferencedComponent = enclosingCore.findReferencedComponent(enclosingComp, refComp);
			if (actualReferencedComponent != null) {
				referencedComponent = aReferencedComponent;
				IReferenceResolver resolver = ReferenceResolverUtil.getDefault().getResolver(this);
				URI uri = resolver.resolve(this).getHandle();
				actualReferencedComponent.setHandle(uri);
					actualReferencedComponent.setHandle(ModuleURIUtil.archiveComponentfullyQualifyURI(referencedComponent.getName()));
				actualReferencedComponent.setDependentObject(dependentObject);
			}
		} finally {




import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.util.URI;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.ModuleCoreNature;
import org.eclipse.wst.common.componentcore.internal.ComponentcoreFactory;
import org.eclipse.wst.common.componentcore.internal.ComponentcorePackage;
import org.eclipse.wst.common.componentcore.internal.DependencyType;
import org.eclipse.wst.common.componentcore.internal.ModulecorePlugin;
import org.eclipse.wst.common.componentcore.internal.Property;
import org.eclipse.wst.common.componentcore.internal.ReferencedComponent;
import org.eclipse.wst.common.componentcore.internal.StructureEdit;
import org.eclipse.wst.common.componentcore.internal.WorkbenchComponent;
import org.eclipse.wst.common.componentcore.internal.builder.IDependencyGraph;
import org.eclipse.wst.common.componentcore.resolvers.IReferenceResolver;
import org.eclipse.wst.common.componentcore.resolvers.ReferenceResolverUtil;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;

						if (referencedComponent==null) 
							continue;
						IVirtualReference vReference = StructureEdit.createVirtualReference(this, referencedComponent);
						if( vReference != null ){
							vReference.setArchiveName( referencedComponent.getArchiveName() );
						}
						if (vReference != null && vReference.getReferencedComponent() != null && vReference.getReferencedComponent().exists())
							references.add(vReference); 
					}

			WorkbenchComponent component = core.getComponent();
			ReferencedComponent referencedComponent = null;
			ComponentcoreFactory factory = ComponentcorePackage.eINSTANCE.getComponentcoreFactory();
			IReferenceResolver resolver = null;
			for (int i=0; i<references.length; i++) {
				if (references[i] == null)
					continue;
				resolver = ReferenceResolverUtil.getDefault().getResolver(references[i]);
				referencedComponent = resolver.resolve(references[i]);
				referencedComponent.setRuntimePath(references[i].getRuntimePath());

				IVirtualComponent comp = references[i].getReferencedComponent();
				if(comp!=null && !comp.isBinary())
					referencedComponent.setHandle(ModuleURIUtil.fullyQualifyURI(comp.getProject()));
				else if (comp!=null)
					referencedComponent.setHandle(ModuleURIUtil.archiveComponentfullyQualifyURI(comp.getName()));
				if (component != null)
					component.getReferencedComponents().add(referencedComponent);
				referencedComponent.setArchiveName(references[i].getArchiveName());
			}
			//clean up any old obsolete references
			if (component != null){

			  
			component.getReferencedComponents().clear();
			ComponentcoreFactory factory = ComponentcorePackage.eINSTANCE.getComponentcoreFactory();
			IReferenceResolver resolver = null;
			for (int i=0; i<references.length; i++) {
				resolver = ReferenceResolverUtil.getDefault().getResolver(references[i]);
				referencedComponent = resolver.resolve(references[i]);
				if( referencedComponent != null)
					component.getReferencedComponents().add(referencedComponent);
				IVirtualComponent comp = references[i].getReferencedComponent();
				if( !comp.isBinary())
					referencedComponent.setHandle(ModuleURIUtil.fullyQualifyURI(references[i].getReferencedComponent().getProject()));
				else
					referencedComponent.setHandle(ModuleURIUtil.archiveComponentfullyQualifyURI(references[i].getReferencedComponent().getName()));
				
				referencedComponent.setArchiveName(references[i].getArchiveName());
				component.getReferencedComponents().add(referencedComponent);
			}
			 
		} finally {

	 * @return array of components
	 */
	public IVirtualComponent[] getReferencingComponents() {
		Set<IProject> projects = IDependencyGraph.INSTANCE.getReferencingComponents(getProject());
		IVirtualComponent[] result = new IVirtualComponent[projects.size()];
		Iterator<IProject> i = projects.iterator();
		for (int j=0; j<projects.size(); j++)
			result[j] = ComponentCore.createComponent(i.next());
		return result;
	}
	

		if (aReference == null || aReference.getReferencedComponent() == null || component == null)
			return null;
		List referencedComponents = component.getReferencedComponents();
		URI uri = ReferenceResolverUtil.getDefault().getResolver(aReference).resolve(aReference).getHandle(); 
		for (int i=0; i<referencedComponents.size(); i++) {
			ReferencedComponent ref = (ReferencedComponent) referencedComponents.get(i);
			if( ref.getHandle().equals(uri))
				return ref;
					return ref;	
			} 
			else {
				if (ref.getHandle().equals(ModuleURIUtil.archiveComponentfullyQualifyURI(aReference.getReferencedComponent().getName())))
					return ref;
			}	
		}
		return null;
	}




import org.eclipse.emf.common.util.URI;
import org.eclipse.jem.util.UIContextDetermination;
import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.IEditModelHandler;
import org.eclipse.wst.common.componentcore.ModuleCoreNature;
import org.eclipse.wst.common.componentcore.UnresolveableURIException;
import org.eclipse.wst.common.componentcore.internal.impl.ModuleURIUtil;
import org.eclipse.wst.common.componentcore.internal.impl.PlatformURLModuleConnection;
import org.eclipse.wst.common.componentcore.internal.impl.ResourceTreeNode;
import org.eclipse.wst.common.componentcore.internal.resources.VirtualReference;
import org.eclipse.wst.common.componentcore.internal.util.EclipseResourceAdapter;
import org.eclipse.wst.common.componentcore.resolvers.IReferenceResolver;
import org.eclipse.wst.common.componentcore.resolvers.ReferenceResolverUtil;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
import org.eclipse.wst.common.internal.emf.utilities.ExtendedEcoreUtil;

		return componentType;
	}

	public static IVirtualReference createVirtualReference(IVirtualComponent context, ReferencedComponent reference) {
		IReferenceResolver resolver = ReferenceResolverUtil.getDefault().getResolver(context, reference);
		return resolver.resolve(context, reference);
		IProject targetProject = null;
		URI uri = referencedComponent.getHandle();
		if (uri == null)
			return null;
		boolean isClassPathURI = ModuleURIUtil.isClassPathURI(uri);
		if( !isClassPathURI ){
			try { 
				targetProject = StructureEdit.getContainingProject(uri);
			} catch(UnresolveableURIException uurie) {
				//Ignore
			} 
			// if the project cannot be resolved, assume it's local - really it probably deleted 
			
			targetComponent = ComponentCore.createComponent(targetProject);  
				

		}else{
			String archiveType = ""; //$NON-NLS-1$
			String archiveName = ""; //$NON-NLS-1$
			try {
				archiveType = ModuleURIUtil.getArchiveType(uri);
				archiveName = ModuleURIUtil.getArchiveName(uri);
				
			} catch (UnresolveableURIException e) {
				//Ignore
			}
			targetComponent = ComponentCore.createArchiveComponent(context.getProject(), archiveType + IPath.SEPARATOR + archiveName ); 
		}
		return new VirtualReference(context, targetComponent, referencedComponent.getRuntimePath(), referencedComponent.getDependencyType().getValue());
	}

	protected StructureEdit(ModuleCoreNature aNature, boolean toAccessAsReadOnly) {

	}

	public static URI createComponentURI(IProject aContainingProject, String aComponentName) {
		return ModuleURIUtil.fullyQualifyURI(aContainingProject, aComponentName);
	}

	
	protected IProject getProject() {
		return aProject;




package org.eclipse.wst.common.componentcore.resolvers;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.Platform;
import org.eclipse.wst.common.componentcore.internal.ModulecorePlugin;
import org.eclipse.wst.common.componentcore.internal.ReferencedComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;

public class ReferenceResolverUtil {
	public static ReferenceResolverUtil instance = null;
	public static ReferenceResolverUtil getDefault() {
		if( instance == null )
			instance = new ReferenceResolverUtil();
		return instance;
	}
	
	private HashMap<String, ReferenceResolverWrapper> resolvers = null;
	private ArrayList<IReferenceResolver> sorted = null;
	private DefaultReferenceResolver defaultResolver = new DefaultReferenceResolver();
	public IReferenceResolver[] getResolvers() {
		if( resolvers == null )
			loadResolvers();
		return (IReferenceResolver[]) sorted.toArray(new IReferenceResolver[sorted.size()]);
	}
	
	public IReferenceResolver getResolver(IVirtualComponent context, ReferencedComponent reference) {
		getResolvers();
		Iterator<IReferenceResolver> i = sorted.iterator();
		IReferenceResolver resolver;
		while(i.hasNext()) {
			resolver = i.next();
			if( resolver.canResolve(context, reference))
				return resolver;
		}
		return defaultResolver;
	}
	
	public IReferenceResolver getResolver(IVirtualReference reference) {
		Iterator<IReferenceResolver> i = sorted.iterator();
		IReferenceResolver resolver;
		while(i.hasNext()) {
			resolver = i.next();
			if( resolver.canResolve(reference))
				return resolver;
		}
		return defaultResolver;
	}
	
	protected void loadResolvers() {
		HashMap<String, ReferenceResolverWrapper> map = new HashMap<String, ReferenceResolverWrapper>();
		
		IExtensionRegistry registry = Platform.getExtensionRegistry();
		IConfigurationElement[] cf = registry.getConfigurationElementsFor(ModulecorePlugin.PLUGIN_ID, "referenceResolver"); //$NON-NLS-1$
		String id = null;
		for( int j = 0; j < cf.length; j++ ) {
			id = cf[j].getAttribute("id");
			try {
				map.put(id, new ReferenceResolverWrapper(
						id, (IReferenceResolver)
							cf[j].createExecutableExtension("class"),
						cf[j].getAttribute("weight")));
			} catch( CoreException ce ) {
				// TODO figure it out
			}
		}
		resolvers = map;
		
		// Cache the sorted ones
		List<ReferenceResolverWrapper> list = new ArrayList(resolvers.values());
		Comparator comparator = new Comparator() { 
			public int compare(Object o1, Object o2) {
				if( !(o1 instanceof ReferenceResolverWrapper))
					return -1;
				if( !(o2 instanceof ReferenceResolverWrapper))
					return 1;
				return ((ReferenceResolverWrapper)o2).getWeight()
				 	- ((ReferenceResolverWrapper)o1).getWeight();
			}
		};
		
		Collections.sort(list, comparator);
		ArrayList<IReferenceResolver> sorted = new ArrayList<IReferenceResolver>();
		Iterator i = list.iterator();
		while(i.hasNext())
			sorted.add(((ReferenceResolverWrapper)i.next()).getResolver());
		this.sorted = sorted;
	}
	
	
	protected class ReferenceResolverWrapper {
		private String id;
		private IReferenceResolver resolver;
		private int weight;
		public ReferenceResolverWrapper(String id, IReferenceResolver resolver, String weight) {
			this.id = id;
			this.resolver = resolver;
			try {
				this.weight = Integer.parseInt(weight);
			} catch( NumberFormatException nfe) {
				this.weight = 1000;
			}
		}
		public int getWeight() {
			return weight;
		}
		public String getId() {
			return id;
		}
		public IReferenceResolver getResolver() {
			return resolver;
		}
	}
	
}




package org.eclipse.wst.common.componentcore.resolvers;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IPath;
import org.eclipse.emf.common.util.URI;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.UnresolveableURIException;
import org.eclipse.wst.common.componentcore.internal.ComponentcorePackage;
import org.eclipse.wst.common.componentcore.internal.DependencyType;
import org.eclipse.wst.common.componentcore.internal.ReferencedComponent;
import org.eclipse.wst.common.componentcore.internal.StructureEdit;
import org.eclipse.wst.common.componentcore.internal.impl.ModuleURIUtil;
import org.eclipse.wst.common.componentcore.internal.resources.VirtualReference;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;

public class DefaultReferenceResolver implements IReferenceResolver {
	// Does not need to implement, 
	// default is always called as last resort
	public boolean canResolve(IVirtualComponent context,
			ReferencedComponent referencedComponent) {
		return false;
	}

	// Does not need to implement, 
	// default is always called as last resort
	public boolean canResolve(IVirtualReference reference) {
		return false;
	}

	public IVirtualReference resolve(IVirtualComponent context,
			ReferencedComponent referencedComponent) {
		IVirtualComponent targetComponent = null;
		IProject targetProject = null;
		URI uri = referencedComponent.getHandle();
		if (uri == null)
			return null;
		boolean isClassPathURI = ModuleURIUtil.isClassPathURI(uri);
		if( !isClassPathURI ){
			try { 
				targetProject = StructureEdit.getContainingProject(uri);
			} catch(UnresolveableURIException uurie) {
				//Ignore
			} 
			// if the project cannot be resolved, assume it's local - really it probably deleted 
			
			targetComponent = ComponentCore.createComponent(targetProject);  
				

		}else{
			String archiveType = ""; //$NON-NLS-1$
			String archiveName = ""; //$NON-NLS-1$
			try {
				archiveType = ModuleURIUtil.getArchiveType(uri);
				archiveName = ModuleURIUtil.getArchiveName(uri);
				
			} catch (UnresolveableURIException e) {
				//Ignore
			}
			targetComponent = ComponentCore.createArchiveComponent(context.getProject(), archiveType + IPath.SEPARATOR + archiveName ); 
		}
		return new VirtualReference(context, targetComponent, referencedComponent.getRuntimePath(), referencedComponent.getDependencyType().getValue());
	}

	public ReferencedComponent resolve(IVirtualReference reference) {
		IVirtualComponent referencedComponent = reference.getReferencedComponent();
		ReferencedComponent refComp = ComponentcorePackage.eINSTANCE.getComponentcoreFactory().createReferencedComponent();
		refComp.setRuntimePath(reference.getRuntimePath());
		refComp.setDependencyType(DependencyType.get(reference.getDependencyType()));
		refComp.setArchiveName(reference.getArchiveName());
		if( referencedComponent != null ) {
			if( !referencedComponent.isBinary())
				refComp.setHandle(ModuleURIUtil.fullyQualifyURI(referencedComponent.getProject()));
			else
				refComp.setHandle(ModuleURIUtil.archiveComponentfullyQualifyURI(referencedComponent.getName())); 
		}
		return refComp;
	}


}




package org.eclipse.wst.common.componentcore.resolvers;

import org.eclipse.wst.common.componentcore.internal.ReferencedComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;

public interface IReferenceResolver {
	public boolean canResolve(IVirtualComponent context, ReferencedComponent referencedComponent);
	public IVirtualReference resolve(IVirtualComponent context, ReferencedComponent referencedComponent);
	public boolean canResolve(IVirtualReference reference);
	public ReferencedComponent resolve(IVirtualReference reference);
}




<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.wst.common.modulecore" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.wst.common.modulecore" id="referenceResolver" name="referenceResolver"/>
      </appInfo>
      <documentation>
         [Enter description of this extension point.]
      </documentation>
   </annotation>

   <element name="extension">
      <annotation>
         <appInfo>
            <meta.element />
         </appInfo>
      </annotation>
      <complexType>
         <sequence minOccurs="1" maxOccurs="unbounded">
            <element ref="resolver"/>
         </sequence>
         <attribute name="point" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="id" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="resolver">
      <complexType>
         <attribute name="id" type="string" use="required">
            <annotation>
               <documentation>
                  A required id which can be used to reference this resolver
               </documentation>
            </annotation>
         </attribute>
         <attribute name="class" type="string" use="required">
            <annotation>
               <documentation>
                  The implementation class of this extension
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn=":org.eclipse.wst.common.componentcore.resolvers.IReferenceResolver"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="weight" type="string">
            <annotation>
               <documentation>
                  The weight used for sorting the resolvers. Lighter weights float to the top and are tried first.
               </documentation>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <annotation>
      <appInfo>
         <meta.section type="since"/>
      </appInfo>
      <documentation>
         [Enter the first release in which this extension point appears.]
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="examples"/>
      </appInfo>
      <documentation>
         [Enter extension point usage example here.]
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="apiinfo"/>
      </appInfo>
      <documentation>
         [Enter API information here.]
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="implementation"/>
      </appInfo>
      <documentation>
         [Enter information about supplied implementation of this extension point.]
      </documentation>
   </annotation>


</schema>

Return to bug 282269

Lines 16-21 Link Here

(-)modulecore-src/org/eclipse/wst/common/componentcore/internal/resources/VirtualComponent.java (-40 / +21 lines)
16	import java.util.List;	16	import java.util.List;
17	import java.util.Map;	17	import java.util.Map;
18	import java.util.Properties;	18	import java.util.Properties;
		19	import java.util.Set;
19		20
20	import org.eclipse.core.resources.IProject;	21	import org.eclipse.core.resources.IProject;
21	import org.eclipse.core.runtime.CoreException;	22	import org.eclipse.core.runtime.CoreException;
Lines 24-41 Link Here
24	import org.eclipse.core.runtime.IStatus;	25	import org.eclipse.core.runtime.IStatus;
25	import org.eclipse.core.runtime.Path;	26	import org.eclipse.core.runtime.Path;
26	import org.eclipse.core.runtime.Platform;	27	import org.eclipse.core.runtime.Platform;
		28	import org.eclipse.emf.common.util.URI;
27	import org.eclipse.wst.common.componentcore.ComponentCore;	29	import org.eclipse.wst.common.componentcore.ComponentCore;
28	import org.eclipse.wst.common.componentcore.ModuleCoreNature;	30	import org.eclipse.wst.common.componentcore.ModuleCoreNature;
29	import org.eclipse.wst.common.componentcore.internal.ComponentcoreFactory;	31	import org.eclipse.wst.common.componentcore.internal.ComponentcoreFactory;
30	import org.eclipse.wst.common.componentcore.internal.ComponentcorePackage;	32	import org.eclipse.wst.common.componentcore.internal.ComponentcorePackage;
31	import org.eclipse.wst.common.componentcore.internal.DependencyType;
32	import org.eclipse.wst.common.componentcore.internal.ModulecorePlugin;	33	import org.eclipse.wst.common.componentcore.internal.ModulecorePlugin;
33	import org.eclipse.wst.common.componentcore.internal.Property;	34	import org.eclipse.wst.common.componentcore.internal.Property;
34	import org.eclipse.wst.common.componentcore.internal.ReferencedComponent;	35	import org.eclipse.wst.common.componentcore.internal.ReferencedComponent;
35	import org.eclipse.wst.common.componentcore.internal.StructureEdit;	36	import org.eclipse.wst.common.componentcore.internal.StructureEdit;
36	import org.eclipse.wst.common.componentcore.internal.WorkbenchComponent;	37	import org.eclipse.wst.common.componentcore.internal.WorkbenchComponent;
37	import org.eclipse.wst.common.componentcore.internal.builder.DependencyGraphManager;	38	import org.eclipse.wst.common.componentcore.internal.builder.IDependencyGraph;
38	import org.eclipse.wst.common.componentcore.internal.impl.ModuleURIUtil;	39	import org.eclipse.wst.common.componentcore.resolvers.IReferenceResolver;
		40	import org.eclipse.wst.common.componentcore.resolvers.ReferenceResolverUtil;
39	import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;	41	import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
40	import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;	42	import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
41	import org.eclipse.wst.common.componentcore.resources.IVirtualReference;	43	import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
Lines 286-294 Link Here
286	if (referencedComponent==null)	288	if (referencedComponent==null)
287	continue;	289	continue;
288	IVirtualReference vReference = StructureEdit.createVirtualReference(this, referencedComponent);	290	IVirtualReference vReference = StructureEdit.createVirtualReference(this, referencedComponent);
289	if( vReference != null ){
290	vReference.setArchiveName( referencedComponent.getArchiveName() );
291	}
292	if (vReference != null && vReference.getReferencedComponent() != null && vReference.getReferencedComponent().exists())	291	if (vReference != null && vReference.getReferencedComponent() != null && vReference.getReferencedComponent().exists())
293	references.add(vReference);	292	references.add(vReference);
294	}	293	}
Lines 312-332 Link Here
312	WorkbenchComponent component = core.getComponent();	311	WorkbenchComponent component = core.getComponent();
313	ReferencedComponent referencedComponent = null;	312	ReferencedComponent referencedComponent = null;
314	ComponentcoreFactory factory = ComponentcorePackage.eINSTANCE.getComponentcoreFactory();	313	ComponentcoreFactory factory = ComponentcorePackage.eINSTANCE.getComponentcoreFactory();
		314	IReferenceResolver resolver = null;
315	for (int i=0; i<references.length; i++) {	315	for (int i=0; i<references.length; i++) {
316	if (references[i] == null)	316	if (references[i] == null)
317	continue;	317	continue;
318	referencedComponent = factory.createReferencedComponent();	318	resolver = ReferenceResolverUtil.getDefault().getResolver(references[i]);
319	referencedComponent.setDependencyType(DependencyType.get(references[i].getDependencyType()));	319	referencedComponent = resolver.resolve(references[i]);
320	referencedComponent.setRuntimePath(references[i].getRuntimePath());
321
322	IVirtualComponent comp = references[i].getReferencedComponent();
323	if(comp!=null && !comp.isBinary())
324	referencedComponent.setHandle(ModuleURIUtil.fullyQualifyURI(comp.getProject()));
325	else if (comp!=null)
326	referencedComponent.setHandle(ModuleURIUtil.archiveComponentfullyQualifyURI(comp.getName()));
327	if (component != null)	320	if (component != null)
328	component.getReferencedComponents().add(referencedComponent);	321	component.getReferencedComponents().add(referencedComponent);
329	referencedComponent.setArchiveName(references[i].getArchiveName());
330	}	322	}
331	//clean up any old obsolete references	323	//clean up any old obsolete references
332	if (component != null){	324	if (component != null){
Lines 362-380 Link Here
362		354
363	component.getReferencedComponents().clear();	355	component.getReferencedComponents().clear();
364	ComponentcoreFactory factory = ComponentcorePackage.eINSTANCE.getComponentcoreFactory();	356	ComponentcoreFactory factory = ComponentcorePackage.eINSTANCE.getComponentcoreFactory();
		357	IReferenceResolver resolver = null;
365	for (int i=0; i<references.length; i++) {	358	for (int i=0; i<references.length; i++) {
366	referencedComponent = factory.createReferencedComponent();	359	resolver = ReferenceResolverUtil.getDefault().getResolver(references[i]);
367	referencedComponent.setDependencyType(DependencyType.get(references[i].getDependencyType()));	360	referencedComponent = resolver.resolve(references[i]);
368	referencedComponent.setRuntimePath(references[i].getRuntimePath());	361	if( referencedComponent != null)
369		362	component.getReferencedComponents().add(referencedComponent);
370	IVirtualComponent comp = references[i].getReferencedComponent();
371	if( !comp.isBinary())
372	referencedComponent.setHandle(ModuleURIUtil.fullyQualifyURI(references[i].getReferencedComponent().getProject()));
373	else
374	referencedComponent.setHandle(ModuleURIUtil.archiveComponentfullyQualifyURI(references[i].getReferencedComponent().getName()));
375
376	referencedComponent.setArchiveName(references[i].getArchiveName());
377	component.getReferencedComponents().add(referencedComponent);
378	}	363	}
379		364
380	} finally {	365	} finally {
Lines 434-443 Link Here
434	* @return array of components	419	* @return array of components
435	*/	420	*/
436	public IVirtualComponent[] getReferencingComponents() {	421	public IVirtualComponent[] getReferencingComponents() {
437	IProject[] handles = DependencyGraphManager.getInstance().getDependencyGraph().getReferencingComponents(getProject());	422	Set<IProject> projects = IDependencyGraph.INSTANCE.getReferencingComponents(getProject());
438	IVirtualComponent[] result = new IVirtualComponent[handles.length];	423	IVirtualComponent[] result = new IVirtualComponent[projects.size()];
439	for (int i=0; i<handles.length; i++)	424	Iterator<IProject> i = projects.iterator();
440	result[i] = ComponentCore.createComponent(handles[i]);	425	for (int j=0; j<projects.size(); j++)
		426	result[j] = ComponentCore.createComponent(i.next());
441	return result;	427	return result;
442	}	428	}
443		429
Lines 477-492 Link Here
477	if (aReference == null \|\| aReference.getReferencedComponent() == null \|\| component == null)	463	if (aReference == null \|\| aReference.getReferencedComponent() == null \|\| component == null)
478	return null;	464	return null;
479	List referencedComponents = component.getReferencedComponents();	465	List referencedComponents = component.getReferencedComponents();
		466	URI uri = ReferenceResolverUtil.getDefault().getResolver(aReference).resolve(aReference).getHandle();
480	for (int i=0; i<referencedComponents.size(); i++) {	467	for (int i=0; i<referencedComponents.size(); i++) {
481	ReferencedComponent ref = (ReferencedComponent) referencedComponents.get(i);	468	ReferencedComponent ref = (ReferencedComponent) referencedComponents.get(i);
482	if (!aReference.getReferencedComponent().isBinary()) {	469	if( ref.getHandle().equals(uri))
483	if (ref.getHandle().equals(ModuleURIUtil.fullyQualifyURI(aReference.getReferencedComponent().getProject())))	470	return ref;
484	return ref;
485	}
486	else {
487	if (ref.getHandle().equals(ModuleURIUtil.archiveComponentfullyQualifyURI(aReference.getReferencedComponent().getName())))
488	return ref;
489	}
490	}	471	}
491	return null;	472	return null;
492	}	473	}

Lines 33-47 Link Here

(-)modulecore-src/org/eclipse/wst/common/componentcore/internal/StructureEdit.java (-37 / +6 lines)
33	import org.eclipse.emf.common.util.URI;	33	import org.eclipse.emf.common.util.URI;
34	import org.eclipse.jem.util.UIContextDetermination;	34	import org.eclipse.jem.util.UIContextDetermination;
35	import org.eclipse.jem.util.emf.workbench.ProjectUtilities;	35	import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
36	import org.eclipse.wst.common.componentcore.ComponentCore;
37	import org.eclipse.wst.common.componentcore.IEditModelHandler;	36	import org.eclipse.wst.common.componentcore.IEditModelHandler;
38	import org.eclipse.wst.common.componentcore.ModuleCoreNature;	37	import org.eclipse.wst.common.componentcore.ModuleCoreNature;
39	import org.eclipse.wst.common.componentcore.UnresolveableURIException;	38	import org.eclipse.wst.common.componentcore.UnresolveableURIException;
40	import org.eclipse.wst.common.componentcore.internal.impl.ModuleURIUtil;	39	import org.eclipse.wst.common.componentcore.internal.impl.ModuleURIUtil;
41	import org.eclipse.wst.common.componentcore.internal.impl.PlatformURLModuleConnection;
42	import org.eclipse.wst.common.componentcore.internal.impl.ResourceTreeNode;	40	import org.eclipse.wst.common.componentcore.internal.impl.ResourceTreeNode;
43	import org.eclipse.wst.common.componentcore.internal.resources.VirtualReference;
44	import org.eclipse.wst.common.componentcore.internal.util.EclipseResourceAdapter;	41	import org.eclipse.wst.common.componentcore.internal.util.EclipseResourceAdapter;
		42	import org.eclipse.wst.common.componentcore.resolvers.IReferenceResolver;
		43	import org.eclipse.wst.common.componentcore.resolvers.ReferenceResolverUtil;
45	import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;	44	import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
46	import org.eclipse.wst.common.componentcore.resources.IVirtualReference;	45	import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
47	import org.eclipse.wst.common.internal.emf.utilities.ExtendedEcoreUtil;	46	import org.eclipse.wst.common.internal.emf.utilities.ExtendedEcoreUtil;
Lines 283-320 Link Here
283	return componentType;	282	return componentType;
284	}	283	}
285		284
286	public static IVirtualReference createVirtualReference(IVirtualComponent context, ReferencedComponent referencedComponent) {	285	public static IVirtualReference createVirtualReference(IVirtualComponent context, ReferencedComponent reference) {
287		286	IReferenceResolver resolver = ReferenceResolverUtil.getDefault().getResolver(context, reference);
288	IVirtualComponent targetComponent = null;	287	return resolver.resolve(context, reference);
289	IProject targetProject = null;
290	URI uri = referencedComponent.getHandle();
291	if (uri == null)
292	return null;
293	boolean isClassPathURI = ModuleURIUtil.isClassPathURI(uri);
294	if( !isClassPathURI ){
295	try {
296	targetProject = StructureEdit.getContainingProject(uri);
297	} catch(UnresolveableURIException uurie) {
298	//Ignore
299	}
300	// if the project cannot be resolved, assume it's local - really it probably deleted
301
302	targetComponent = ComponentCore.createComponent(targetProject);
303
304
305	}else{
306	String archiveType = ""; //$NON-NLS-1$
307	String archiveName = ""; //$NON-NLS-1$
308	try {
309	archiveType = ModuleURIUtil.getArchiveType(uri);
310	archiveName = ModuleURIUtil.getArchiveName(uri);
311
312	} catch (UnresolveableURIException e) {
313	//Ignore
314	}
315	targetComponent = ComponentCore.createArchiveComponent(context.getProject(), archiveType + IPath.SEPARATOR + archiveName );
316	}
317	return new VirtualReference(context, targetComponent, referencedComponent.getRuntimePath(), referencedComponent.getDependencyType().getValue());
318	}	288	}
319		289
320	protected StructureEdit(ModuleCoreNature aNature, boolean toAccessAsReadOnly) {	290	protected StructureEdit(ModuleCoreNature aNature, boolean toAccessAsReadOnly) {
Lines 950-958 Link Here
950	}	920	}
951		921
952	public static URI createComponentURI(IProject aContainingProject, String aComponentName) {	922	public static URI createComponentURI(IProject aContainingProject, String aComponentName) {
953	return URI.createURI(PlatformURLModuleConnection.MODULE_PROTOCOL + IPath.SEPARATOR + PlatformURLModuleConnection.RESOURCE_MODULE + aContainingProject.getName() + IPath.SEPARATOR + aComponentName);	923	return ModuleURIUtil.fullyQualifyURI(aContainingProject, aComponentName);
954	}	924	}
955
956		925
957	protected IProject getProject() {	926	protected IProject getProject() {
958	return aProject;	927	return aProject;

Lines 16-28 Link Here

(-)modulecore-src/org/eclipse/wst/common/componentcore/internal/resources/VirtualReference.java (-15 / +8 lines)
16	import org.eclipse.core.runtime.IProgressMonitor;	16	import org.eclipse.core.runtime.IProgressMonitor;
17	import org.eclipse.core.runtime.NullProgressMonitor;	17	import org.eclipse.core.runtime.NullProgressMonitor;
18	import org.eclipse.core.runtime.Path;	18	import org.eclipse.core.runtime.Path;
		19	import org.eclipse.emf.common.util.URI;
19	import org.eclipse.emf.ecore.EObject;	20	import org.eclipse.emf.ecore.EObject;
20	import org.eclipse.wst.common.componentcore.internal.ComponentcorePackage;
21	import org.eclipse.wst.common.componentcore.internal.DependencyType;
22	import org.eclipse.wst.common.componentcore.internal.ReferencedComponent;	21	import org.eclipse.wst.common.componentcore.internal.ReferencedComponent;
23	import org.eclipse.wst.common.componentcore.internal.StructureEdit;	22	import org.eclipse.wst.common.componentcore.internal.StructureEdit;
24	import org.eclipse.wst.common.componentcore.internal.WorkbenchComponent;	23	import org.eclipse.wst.common.componentcore.internal.WorkbenchComponent;
25	import org.eclipse.wst.common.componentcore.internal.impl.ModuleURIUtil;	24	import org.eclipse.wst.common.componentcore.resolvers.IReferenceResolver;
		25	import org.eclipse.wst.common.componentcore.resolvers.ReferenceResolverUtil;
26	import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;	26	import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
27	import org.eclipse.wst.common.componentcore.resources.IVirtualReference;	27	import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
28		28
Lines 59-72 Link Here
59	core = StructureEdit.getStructureEditForWrite(enclosingComponent.getProject());	59	core = StructureEdit.getStructureEditForWrite(enclosingComponent.getProject());
60	WorkbenchComponent component = core.getComponent();	60	WorkbenchComponent component = core.getComponent();
61	List referencedComponents = component.getReferencedComponents();	61	List referencedComponents = component.getReferencedComponents();
62	ReferencedComponent refComp = ComponentcorePackage.eINSTANCE.getComponentcoreFactory().createReferencedComponent();	62	IReferenceResolver resolver = ReferenceResolverUtil.getDefault().getResolver(this);
63	if( !referencedComponent.isBinary())	63	ReferencedComponent refComp = resolver.resolve(this);
64	refComp.setHandle(ModuleURIUtil.fullyQualifyURI(referencedComponent.getProject()));
65	else
66	refComp.setHandle(ModuleURIUtil.archiveComponentfullyQualifyURI(referencedComponent.getName()));
67	refComp.setRuntimePath(runtimePath);
68	refComp.setDependencyType(DependencyType.get(dependencyType));
69	refComp.setArchiveName(archiveName);
70	if(!referencedComponents.contains(refComp)){	64	if(!referencedComponents.contains(refComp)){
71	referencedComponents.add(refComp);	65	referencedComponents.add(refComp);
72	}	66	}
Lines 123-132 Link Here
123	ReferencedComponent actualReferencedComponent = enclosingCore.findReferencedComponent(enclosingComp, refComp);	117	ReferencedComponent actualReferencedComponent = enclosingCore.findReferencedComponent(enclosingComp, refComp);
124	if (actualReferencedComponent != null) {	118	if (actualReferencedComponent != null) {
125	referencedComponent = aReferencedComponent;	119	referencedComponent = aReferencedComponent;
126	if(!referencedComponent.isBinary())	120	IReferenceResolver resolver = ReferenceResolverUtil.getDefault().getResolver(this);
127	actualReferencedComponent.setHandle(ModuleURIUtil.fullyQualifyURI(referencedComponent.getProject()));	121	URI uri = resolver.resolve(this).getHandle();
128	else	122	actualReferencedComponent.setHandle(uri);
129	actualReferencedComponent.setHandle(ModuleURIUtil.archiveComponentfullyQualifyURI(referencedComponent.getName()));
130	actualReferencedComponent.setDependentObject(dependentObject);	123	actualReferencedComponent.setDependentObject(dependentObject);
131	}	124	}
132	} finally {	125	} finally {

Added Link Here

(-)modulecore-src/org/eclipse/wst/common/componentcore/resolvers/ReferenceResolverUtil.java (+124 lines)
1	package org.eclipse.wst.common.componentcore.resolvers;
2
3	import java.util.ArrayList;
4	import java.util.Collections;
5	import java.util.Comparator;
6	import java.util.HashMap;
7	import java.util.Iterator;
8	import java.util.List;
9
10	import org.eclipse.core.runtime.CoreException;
11	import org.eclipse.core.runtime.IConfigurationElement;
12	import org.eclipse.core.runtime.IExtensionRegistry;
13	import org.eclipse.core.runtime.Platform;
14	import org.eclipse.wst.common.componentcore.internal.ModulecorePlugin;
15	import org.eclipse.wst.common.componentcore.internal.ReferencedComponent;
16	import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
17	import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
18
19	public class ReferenceResolverUtil {
20	public static ReferenceResolverUtil instance = null;
21	public static ReferenceResolverUtil getDefault() {
22	if( instance == null )
23	instance = new ReferenceResolverUtil();
24	return instance;
25	}
26
27	private HashMap<String, ReferenceResolverWrapper> resolvers = null;
28	private ArrayList<IReferenceResolver> sorted = null;
29	private DefaultReferenceResolver defaultResolver = new DefaultReferenceResolver();
30	public IReferenceResolver[] getResolvers() {
31	if( resolvers == null )
32	loadResolvers();
33	return (IReferenceResolver[]) sorted.toArray(new IReferenceResolver[sorted.size()]);
34	}
35
36	public IReferenceResolver getResolver(IVirtualComponent context, ReferencedComponent reference) {
37	getResolvers();
38	Iterator<IReferenceResolver> i = sorted.iterator();
39	IReferenceResolver resolver;
40	while(i.hasNext()) {
41	resolver = i.next();
42	if( resolver.canResolve(context, reference))
43	return resolver;
44	}
45	return defaultResolver;
46	}
47
48	public IReferenceResolver getResolver(IVirtualReference reference) {
49	Iterator<IReferenceResolver> i = sorted.iterator();
50	IReferenceResolver resolver;
51	while(i.hasNext()) {
52	resolver = i.next();
53	if( resolver.canResolve(reference))
54	return resolver;
55	}
56	return defaultResolver;
57	}
58
59	protected void loadResolvers() {
60	HashMap<String, ReferenceResolverWrapper> map = new HashMap<String, ReferenceResolverWrapper>();
61
62	IExtensionRegistry registry = Platform.getExtensionRegistry();
63	IConfigurationElement[] cf = registry.getConfigurationElementsFor(ModulecorePlugin.PLUGIN_ID, "referenceResolver"); //$NON-NLS-1$
64	String id = null;
65	for( int j = 0; j < cf.length; j++ ) {
66	id = cf[j].getAttribute("id");
67	try {
68	map.put(id, new ReferenceResolverWrapper(
69	id, (IReferenceResolver)
70	cf[j].createExecutableExtension("class"),
71	cf[j].getAttribute("weight")));
72	} catch( CoreException ce ) {
73	// TODO figure it out
74	}
75	}
76	resolvers = map;
77
78	// Cache the sorted ones
79	List<ReferenceResolverWrapper> list = new ArrayList(resolvers.values());
80	Comparator comparator = new Comparator() {
81	public int compare(Object o1, Object o2) {
82	if( !(o1 instanceof ReferenceResolverWrapper))
83	return -1;
84	if( !(o2 instanceof ReferenceResolverWrapper))
85	return 1;
86	return ((ReferenceResolverWrapper)o2).getWeight()
87	- ((ReferenceResolverWrapper)o1).getWeight();
88	}
89	};
90
91	Collections.sort(list, comparator);
92	ArrayList<IReferenceResolver> sorted = new ArrayList<IReferenceResolver>();
93	Iterator i = list.iterator();
94	while(i.hasNext())
95	sorted.add(((ReferenceResolverWrapper)i.next()).getResolver());
96	this.sorted = sorted;
97	}
98
99
100	protected class ReferenceResolverWrapper {
101	private String id;
102	private IReferenceResolver resolver;
103	private int weight;
104	public ReferenceResolverWrapper(String id, IReferenceResolver resolver, String weight) {
105	this.id = id;
106	this.resolver = resolver;
107	try {
108	this.weight = Integer.parseInt(weight);
109	} catch( NumberFormatException nfe) {
110	this.weight = 1000;
111	}
112	}
113	public int getWeight() {
114	return weight;
115	}
116	public String getId() {
117	return id;
118	}
119	public IReferenceResolver getResolver() {
120	return resolver;
121	}
122	}
123
124	}

Added Link Here

(-)schema/referenceResolver.exsd (+116 lines)
1	<?xml version='1.0' encoding='UTF-8'?>
2	<!-- Schema file written by PDE -->
3	<schema targetNamespace="org.eclipse.wst.common.modulecore" xmlns="http://www.w3.org/2001/XMLSchema">
4	<annotation>
5	<appInfo>
6	<meta.schema plugin="org.eclipse.wst.common.modulecore" id="referenceResolver" name="referenceResolver"/>
7	</appInfo>
8	<documentation>
9	[Enter description of this extension point.]
10	</documentation>
11	</annotation>
12
13	<element name="extension">
14	<annotation>
15	<appInfo>
16	<meta.element />
17	</appInfo>
18	</annotation>
19	<complexType>
20	<sequence minOccurs="1" maxOccurs="unbounded">
21	<element ref="resolver"/>
22	</sequence>
23	<attribute name="point" type="string" use="required">
24	<annotation>
25	<documentation>
26
27	</documentation>
28	</annotation>
29	</attribute>
30	<attribute name="id" type="string">
31	<annotation>
32	<documentation>
33
34	</documentation>
35	</annotation>
36	</attribute>
37	<attribute name="name" type="string">
38	<annotation>
39	<documentation>
40
41	</documentation>
42	<appInfo>
43	<meta.attribute translatable="true"/>
44	</appInfo>
45	</annotation>
46	</attribute>
47	</complexType>
48	</element>
49
50	<element name="resolver">
51	<complexType>
52	<attribute name="id" type="string" use="required">
53	<annotation>
54	<documentation>
55	A required id which can be used to reference this resolver
56	</documentation>
57	</annotation>
58	</attribute>
59	<attribute name="class" type="string" use="required">
60	<annotation>
61	<documentation>
62	The implementation class of this extension
63	</documentation>
64	<appInfo>
65	<meta.attribute kind="java" basedOn=":org.eclipse.wst.common.componentcore.resolvers.IReferenceResolver"/>
66	</appInfo>
67	</annotation>
68	</attribute>
69	<attribute name="weight" type="string">
70	<annotation>
71	<documentation>
72	The weight used for sorting the resolvers. Lighter weights float to the top and are tried first.
73	</documentation>
74	</annotation>
75	</attribute>
76	</complexType>
77	</element>
78
79	<annotation>
80	<appInfo>
81	<meta.section type="since"/>
82	</appInfo>
83	<documentation>
84	[Enter the first release in which this extension point appears.]
85	</documentation>
86	</annotation>
87
88	<annotation>
89	<appInfo>
90	<meta.section type="examples"/>
91	</appInfo>
92	<documentation>
93	[Enter extension point usage example here.]
94	</documentation>
95	</annotation>
96
97	<annotation>
98	<appInfo>
99	<meta.section type="apiinfo"/>
100	</appInfo>
101	<documentation>
102	[Enter API information here.]
103	</documentation>
104	</annotation>
105
106	<annotation>
107	<appInfo>
108	<meta.section type="implementation"/>
109	</appInfo>
110	<documentation>
111	[Enter information about supplied implementation of this extension point.]
112	</documentation>
113	</annotation>
114
115
116	</schema>