Attachment 79065 Details for Bug 200803 – version bump of this patch

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

[patch] version bump of this patch

patch.txt (text/plain), 20.06 KB, created by Markus Kuppe

on 2007-09-24 07:23:43 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Markus Kuppe

Created: 2007-09-24 07:23:43 EDT

Size: 20.06 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.ecf.discovery
>Index: META-INF/MANIFEST.MF
>===================================================================
>RCS file: /cvsroot/technology/org.eclipse.ecf/plugins/org.eclipse.ecf.discovery/META-INF/MANIFEST.MF,v
>retrieving revision 1.81
>diff -u -r1.81 MANIFEST.MF
>--- META-INF/MANIFEST.MF	6 Sep 2007 04:42:05 -0000	1.81
>+++ META-INF/MANIFEST.MF	24 Sep 2007 11:22:00 -0000
>@@ -15,4 +15,5 @@
>  J2SE-1.3
> Require-Bundle: org.eclipse.equinox.common,
>  org.eclipse.ecf
>-Import-Package: org.osgi.framework;version="1.3.0"
>+Import-Package: org.eclipse.osgi.util;version="1.1.0",
>+ org.osgi.framework;version="1.3.0"
>Index: plugin.xml
>===================================================================
>RCS file: /cvsroot/technology/org.eclipse.ecf/plugins/org.eclipse.ecf.discovery/plugin.xml,v
>retrieving revision 1.1
>diff -u -r1.1 plugin.xml
>--- plugin.xml	7 Dec 2006 01:52:38 -0000	1.1
>+++ plugin.xml	24 Sep 2007 11:22:00 -0000
>@@ -1,5 +1,14 @@
> <?xml version="1.0" encoding="UTF-8"?>
> <?eclipse version="3.2"?>
> <plugin>
>+   <extension
>+         point="org.eclipse.ecf.containerFactory">
>+      <containerFactory
>+            class="org.eclipse.ecf.internal.discovery.CompositeDiscoveryContainerInstantiator"
>+            description="Composite Discovery Container"
>+            name="ecf.discovery.*"
>+            server="true">
>+       </containerFactory>
>+   </extension>
> 
> </plugin>
>Index: src/org/eclipse/ecf/internal/discovery/CompositeDiscoveryContainer.java
>===================================================================
>RCS file: src/org/eclipse/ecf/internal/discovery/CompositeDiscoveryContainer.java
>diff -N src/org/eclipse/ecf/internal/discovery/CompositeDiscoveryContainer.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/ecf/internal/discovery/CompositeDiscoveryContainer.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,389 @@
>+/*******************************************************************************
>+ * Copyright (c) 2007 Versant Corp.
>+ * 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:
>+ *     Markus Kuppe (mkuppe <at> versant <dot> com) - initial API and implementation
>+ ******************************************************************************/
>+package org.eclipse.ecf.internal.discovery;
>+
>+import java.util.*;
>+import org.eclipse.ecf.core.*;
>+import org.eclipse.ecf.core.events.ContainerDisconnectedEvent;
>+import org.eclipse.ecf.core.events.ContainerDisconnectingEvent;
>+import org.eclipse.ecf.core.identity.*;
>+import org.eclipse.ecf.core.security.IConnectContext;
>+import org.eclipse.ecf.core.util.ECFException;
>+import org.eclipse.ecf.discovery.*;
>+import org.eclipse.ecf.discovery.identity.IServiceID;
>+import org.eclipse.ecf.discovery.identity.IServiceTypeID;
>+import org.eclipse.ecf.discovery.service.IDiscoveryService;
>+
>+public class CompositeDiscoveryContainer extends AbstractContainer implements IContainer, IDiscoveryService {
>+	private class CompositeContainerServiceListener implements IServiceListener {
>+
>+		/*
>+		 * (non-Javadoc)
>+		 * 
>+		 * @see org.eclipse.ecf.discovery.IServiceListener#serviceAdded(org.eclipse.ecf.discovery.IServiceEvent)
>+		 */
>+		public void serviceAdded(IServiceEvent event) {
>+			synchronized (serviceListeners) {
>+				//TODO fix race condition
>+				Collection col = (Collection) serviceListeners.get(event.getServiceInfo().getServiceID().getServiceTypeID());
>+				if (col != null) {
>+					synchronized (col) {
>+						for (Iterator itr = col.iterator(); itr.hasNext();) {
>+							IServiceListener isl = (IServiceListener) itr.next();
>+							isl.serviceAdded(event);
>+						}
>+					}
>+				}
>+			}
>+		}
>+
>+		/*
>+		 * (non-Javadoc)
>+		 * 
>+		 * @see org.eclipse.ecf.discovery.IServiceListener#serviceRemoved(org.eclipse.ecf.discovery.IServiceEvent)
>+		 */
>+		public void serviceRemoved(IServiceEvent event) {
>+			synchronized (serviceListeners) {
>+				Collection col = (Collection) serviceListeners.get(event.getServiceInfo().getServiceID().getServiceTypeID());
>+				if (col != null) {
>+					synchronized (col) {
>+						for (Iterator itr = col.iterator(); itr.hasNext();) {
>+							IServiceListener isl = (IServiceListener) itr.next();
>+							isl.serviceRemoved(event);
>+						}
>+					}
>+				}
>+			}
>+		}
>+
>+		/*
>+		 * (non-Javadoc)
>+		 * 
>+		 * @see org.eclipse.ecf.discovery.IServiceListener#serviceResolved(org.eclipse.ecf.discovery.IServiceEvent)
>+		 */
>+		public void serviceResolved(IServiceEvent event) {
>+			synchronized (serviceListeners) {
>+				Collection col = (Collection) serviceListeners.get(event.getServiceInfo().getServiceID().getServiceTypeID());
>+				if (col != null) {
>+					synchronized (col) {
>+						for (Iterator itr = col.iterator(); itr.hasNext();) {
>+							IServiceListener isl = (IServiceListener) itr.next();
>+							isl.serviceResolved(event);
>+						}
>+					}
>+				}
>+			}
>+		}
>+	}
>+
>+	private class CompositeContainerServiceTypeListener implements IServiceTypeListener {
>+
>+		/*
>+		 * (non-Javadoc)
>+		 * 
>+		 * @see org.eclipse.ecf.discovery.IServiceTypeListener#serviceTypeAdded(org.eclipse.ecf.discovery.IServiceEvent)
>+		 */
>+		public void serviceTypeAdded(IServiceEvent event) {
>+			// add ourself as a listener to the underlying providers
>+			IServiceTypeID istid = event.getServiceInfo().getServiceID().getServiceTypeID();
>+			synchronized (containers) {
>+				for (Iterator itr = containers.iterator(); itr.hasNext();) {
>+					//TODO ccstl doesn't have to be a listener for a non matching (namespace) container, but it doesn't hurt either
>+					IDiscoveryContainerAdapter idca = (IDiscoveryContainerAdapter) itr.next();
>+					idca.addServiceListener(istid, ccsl);
>+				}
>+			}
>+			// notify our listeners
>+			synchronized (serviceTypeListeners) {
>+				for (Iterator itr = serviceTypeListeners.iterator(); itr.hasNext();) {
>+					IServiceTypeListener listener = (IServiceTypeListener) itr.next();
>+					listener.serviceTypeAdded(event);
>+				}
>+			}
>+		}
>+	}
>+
>+	protected CompositeContainerServiceListener ccsl = new CompositeContainerServiceListener();
>+	protected CompositeContainerServiceTypeListener ccstl = new CompositeContainerServiceTypeListener();
>+
>+	protected List containers = new ArrayList();
>+
>+	private ID id;
>+
>+	protected Map serviceListeners = new HashMap();
>+
>+	protected Collection serviceTypeListeners = new HashSet();
>+
>+	public CompositeDiscoveryContainer(List containers) throws IDCreateException {
>+		this.containers = containers;
>+		this.id = IDFactory.getDefault().createStringID(CompositeDiscoveryContainer.class.getName());
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#addServiceListener(org.eclipse.ecf.discovery.identity.IServiceTypeID,
>+	 *      org.eclipse.ecf.discovery.IServiceListener)
>+	 */
>+	public void addServiceListener(IServiceTypeID type, IServiceListener listener) {
>+		synchronized (serviceListeners) {
>+			Collection col = (Collection) serviceListeners.get(type);
>+			if (col == null) {
>+				col = new HashSet();
>+				serviceListeners.put(type, col);
>+			}
>+			col.add(listener);
>+		}
>+	}
>+
>+	/**
>+	 * @deprecated
>+	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#addServiceListener(java.lang.String,
>+	 *      org.eclipse.ecf.discovery.IServiceListener)
>+	 */
>+	public void addServiceListener(String type, IServiceListener listener) {
>+		throw new UnsupportedOperationException(Messages.CompositeDiscoveryContainer_DEPRECATED);
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#addServiceTypeListener(org.eclipse.ecf.discovery.IServiceTypeListener)
>+	 */
>+	public void addServiceTypeListener(IServiceTypeListener listener) {
>+		synchronized (serviceTypeListeners) {
>+			serviceTypeListeners.add(listener);
>+		}
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see org.eclipse.ecf.core.IContainer#connect(org.eclipse.ecf.core.identity.ID,
>+	 *      org.eclipse.ecf.core.security.IConnectContext)
>+	 */
>+	public void connect(ID targetID, IConnectContext connectContext) throws ContainerConnectException {
>+		synchronized (containers) {
>+			for (Iterator itr = containers.iterator(); itr.hasNext();) {
>+				IContainer container = (IContainer) itr.next();
>+				container.connect(targetID, connectContext);
>+				IDiscoveryContainerAdapter idca = (IDiscoveryContainerAdapter) container;
>+				idca.addServiceTypeListener(ccstl);
>+			}
>+		}
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see org.eclipse.ecf.core.IContainer#disconnect()
>+	 */
>+	public void disconnect() {
>+		fireContainerEvent(new ContainerDisconnectingEvent(this.getID(), getConnectedID()));
>+		synchronized (containers) {
>+			for (Iterator itr = containers.iterator(); itr.hasNext();) {
>+				IContainer container = (IContainer) itr.next();
>+				container.disconnect();
>+			}
>+		}
>+		fireContainerEvent(new ContainerDisconnectedEvent(this.getID(), getConnectedID()));
>+	}
>+
>+	/* (non-Javadoc)
>+	 * @see org.eclipse.ecf.core.AbstractContainer#dispose()
>+	 */
>+	public void dispose() {
>+		disconnect();
>+		synchronized (containers) {
>+			for (Iterator itr = containers.iterator(); itr.hasNext();) {
>+				IContainer container = (IContainer) itr.next();
>+				container.dispose();
>+			}
>+		}
>+		super.dispose();
>+	}
>+
>+	/* (non-Javadoc)
>+	 * @see org.eclipse.ecf.core.IContainer#getConnectedID()
>+	 */
>+	public ID getConnectedID() {
>+		return getID();
>+	}
>+
>+	/* (non-Javadoc)
>+	 * @see org.eclipse.ecf.core.IContainer#getConnectNamespace()
>+	 */
>+	public Namespace getConnectNamespace() {
>+		throw new UnsupportedOperationException("not yet implemented"); //$NON-NLS-1$
>+	}
>+
>+	/**
>+	 * Get the IContainer for the given Namespace
>+	 * @param aNamespace 
>+	 * @return The IDiscoveryContainerAdapter for the given Namespace
>+	 */
>+	private IDiscoveryContainerAdapter getContainerByNamespace(Namespace aNamespace) {
>+		synchronized (containers) {
>+			for (Iterator itr = containers.iterator(); itr.hasNext();) {
>+				IContainer container = (IContainer) itr.next();
>+				// TODO handle the case for the generic ServiceID which should work with all containers
>+				// could be done by a smart equals impl or better a comparator
>+				Namespace containerNamespace = container.getConnectNamespace();
>+				if (containerNamespace.equals(aNamespace)) {
>+					return (IDiscoveryContainerAdapter) container;
>+				}
>+			}
>+		}
>+		return null;
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see org.eclipse.ecf.core.identity.IIdentifiable#getID()
>+	 */
>+	public ID getID() {
>+		return id;
>+	}
>+
>+	/* (non-Javadoc)
>+	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#getServiceInfo(org.eclipse.ecf.discovery.identity.IServiceID, int)
>+	 */
>+	public IServiceInfo getServiceInfo(IServiceID aService, int timeout) {
>+		synchronized (containers) {
>+			for (Iterator itr = containers.iterator(); itr.hasNext();) {
>+				IDiscoveryContainerAdapter idca = (IDiscoveryContainerAdapter) itr.next();
>+				IServiceInfo service = idca.getServiceInfo(aService, timeout);
>+				if (service != null) {
>+					return service;
>+				}
>+			}
>+		}
>+		return null;
>+	}
>+
>+	/* (non-Javadoc)
>+	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#getServices(org.eclipse.ecf.discovery.identity.IServiceTypeID)
>+	 */
>+	public IServiceInfo[] getServices(IServiceTypeID type) {
>+		Set set = new HashSet();
>+		synchronized (containers) {
>+			for (Iterator itr = containers.iterator(); itr.hasNext();) {
>+				IDiscoveryContainerAdapter idca = (IDiscoveryContainerAdapter) itr.next();
>+				IServiceInfo[] services = idca.getServices(type);
>+				for (int i = 0; i < services.length; i++) {
>+					set.add(services[i]);
>+				}
>+			}
>+		}
>+		return (IServiceInfo[]) set.toArray(new IServiceInfo[set.size()]);
>+	}
>+
>+	/**
>+	 * @deprecated
>+	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#getServices(java.lang.String)
>+	 */
>+	public IServiceInfo[] getServices(String type) {
>+		throw new UnsupportedOperationException(Messages.CompositeDiscoveryContainer_DEPRECATED);
>+	}
>+
>+	/* (non-Javadoc)
>+	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#getServicesNamespace()
>+	 */
>+	public Namespace getServicesNamespace() {
>+		throw new UnsupportedOperationException("not yet implemented"); //$NON-NLS-1$
>+	}
>+
>+	/* (non-Javadoc)
>+	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#registerService(org.eclipse.ecf.discovery.IServiceInfo)
>+	 */
>+	public void registerService(IServiceInfo serviceInfo) throws ECFException {
>+		IDiscoveryContainerAdapter idca = getContainerByNamespace(serviceInfo.getServiceID().getNamespace());
>+		if (idca != null) {
>+			idca.registerService(serviceInfo);
>+		}
>+	}
>+
>+	/* (non-Javadoc)
>+	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#registerServiceType(org.eclipse.ecf.discovery.identity.IServiceTypeID)
>+	 */
>+	public void registerServiceType(IServiceTypeID type) {
>+		IDiscoveryContainerAdapter idca = getContainerByNamespace(type.getNamespace());
>+		if (idca != null) {
>+			idca.registerServiceType(type);
>+		}
>+	}
>+
>+	/**
>+	 * @deprecated
>+	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#registerServiceType(java.lang.String)
>+	 */
>+	public void registerServiceType(String serviceType) {
>+		throw new UnsupportedOperationException(Messages.CompositeDiscoveryContainer_DEPRECATED);
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#removeServiceListener(org.eclipse.ecf.discovery.identity.IServiceTypeID,
>+	 *      org.eclipse.ecf.discovery.IServiceListener)
>+	 */
>+	public void removeServiceListener(IServiceTypeID type, IServiceListener listener) {
>+		synchronized (serviceListeners) {
>+			Collection col = (Collection) serviceListeners.get(type);
>+			synchronized (col) {
>+				col.remove(listener);
>+			}
>+		}
>+	}
>+
>+	/**
>+	 * @deprecated
>+	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#removeServiceListener(java.lang.String,
>+	 *      org.eclipse.ecf.discovery.IServiceListener)
>+	 */
>+	public void removeServiceListener(String type, IServiceListener listener) {
>+		throw new UnsupportedOperationException(Messages.CompositeDiscoveryContainer_DEPRECATED);
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#removeServiceTypeListener(org.eclipse.ecf.discovery.IServiceTypeListener)
>+	 */
>+	public void removeServiceTypeListener(IServiceTypeListener listener) {
>+		synchronized (serviceTypeListeners) {
>+			serviceTypeListeners.remove(listener);
>+		}
>+	}
>+
>+	/* (non-Javadoc)
>+	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#requestServiceInfo(org.eclipse.ecf.discovery.identity.IServiceID, int)
>+	 */
>+	public void requestServiceInfo(IServiceID service, int timeout) {
>+		IDiscoveryContainerAdapter idca = getContainerByNamespace(service.getNamespace());
>+		if (idca != null) {
>+			idca.requestServiceInfo(service, timeout);
>+		}
>+	}
>+
>+	/* (non-Javadoc)
>+	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#unregisterService(org.eclipse.ecf.discovery.IServiceInfo)
>+	 */
>+	public void unregisterService(IServiceInfo serviceInfo) {
>+		synchronized (containers) {
>+			for (Iterator itr = containers.iterator(); itr.hasNext();) {
>+				IDiscoveryContainerAdapter idca = (IDiscoveryContainerAdapter) itr.next();
>+				idca.unregisterService(serviceInfo);
>+			}
>+		}
>+	}
>+}
>Index: src/org/eclipse/ecf/internal/discovery/Messages.java
>===================================================================
>RCS file: src/org/eclipse/ecf/internal/discovery/Messages.java
>diff -N src/org/eclipse/ecf/internal/discovery/Messages.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/ecf/internal/discovery/Messages.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,17 @@
>+package org.eclipse.ecf.internal.discovery;
>+
>+import org.eclipse.osgi.util.NLS;
>+
>+public class Messages extends NLS {
>+	private static final String BUNDLE_NAME = "org.eclipse.ecf.internal.discovery.messages"; //$NON-NLS-1$
>+	public static String CompositeDiscoveryContainer_DEPRECATED;
>+	public static String CompositeDiscoveryContainerInstantiator_2;
>+	public static String CompositeDiscoveryContainerInstantiator_3;
>+	static {
>+		// initialize resource bundle
>+		NLS.initializeMessages(BUNDLE_NAME, Messages.class);
>+	}
>+
>+	private Messages() {
>+	}
>+}
>Index: src/org/eclipse/ecf/internal/discovery/messages.properties
>===================================================================
>RCS file: src/org/eclipse/ecf/internal/discovery/messages.properties
>diff -N src/org/eclipse/ecf/internal/discovery/messages.properties
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/ecf/internal/discovery/messages.properties	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,3 @@
>+CompositeDiscoveryContainerInstantiator_2=Exception making Composite container
>+CompositeDiscoveryContainerInstantiator_3=Exception making Composite container
>+CompositeDiscoveryContainer_DEPRECATED=deprecated API isn't supported by CompositeContainer
>Index: src/org/eclipse/ecf/internal/discovery/CompositeDiscoveryContainerInstantiator.java
>===================================================================
>RCS file: src/org/eclipse/ecf/internal/discovery/CompositeDiscoveryContainerInstantiator.java
>diff -N src/org/eclipse/ecf/internal/discovery/CompositeDiscoveryContainerInstantiator.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/ecf/internal/discovery/CompositeDiscoveryContainerInstantiator.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,73 @@
>+/*******************************************************************************
>+ * Copyright (c) 2007 Versant Corp.
>+ * 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:
>+ *     Markus Kuppe (mkuppe <at> versant <dot> com) - initial API and implementation
>+ ******************************************************************************/
>+
>+package org.eclipse.ecf.internal.discovery;
>+
>+import java.util.*;
>+import org.eclipse.ecf.core.*;
>+import org.eclipse.ecf.core.identity.IDCreateException;
>+import org.eclipse.ecf.core.provider.IContainerInstantiator;
>+import org.eclipse.ecf.discovery.IDiscoveryContainerAdapter;
>+
>+public class CompositeDiscoveryContainerInstantiator implements IContainerInstantiator {
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see org.eclipse.ecf.core.provider.IContainerInstantiator#createInstance(org.eclipse.ecf.core.ContainerTypeDescription,
>+	 *      java.lang.Object[])
>+	 */
>+	public IContainer createInstance(ContainerTypeDescription description, Object[] parameters) throws ContainerCreateException {
>+
>+		try {
>+			IContainerFactory factory = ContainerFactory.getDefault();
>+			List containers = new ArrayList();
>+			List list = factory.getDescriptions();
>+			for (Iterator itr = list.iterator(); itr.hasNext();) {
>+				ContainerTypeDescription ctd = (ContainerTypeDescription) itr.next();
>+				String name = ctd.getName();
>+				if (!name.equals("ecf.discovery.*") //$NON-NLS-1$
>+						&& name.startsWith("ecf.discovery.")) { //$NON-NLS-1$
>+					IContainer container = factory.createContainer(ctd.getName());
>+					containers.add(container);
>+				}
>+			}
>+			return new CompositeDiscoveryContainer(containers);
>+		} catch (IDCreateException e) {
>+			ContainerCreateException excep = new ContainerCreateException(Messages.CompositeDiscoveryContainerInstantiator_2);
>+			excep.setStackTrace(e.getStackTrace());
>+			throw excep;
>+		} catch (ContainerCreateException e) {
>+			ContainerCreateException excep = new ContainerCreateException(Messages.CompositeDiscoveryContainerInstantiator_3);
>+			excep.setStackTrace(e.getStackTrace());
>+			throw excep;
>+		}
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see org.eclipse.ecf.core.provider.IContainerInstantiator#getSupportedAdapterTypes(org.eclipse.ecf.core.ContainerTypeDescription)
>+	 */
>+	public String[] getSupportedAdapterTypes(ContainerTypeDescription description) {
>+		return new String[] {IDiscoveryContainerAdapter.class.getName()};
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see org.eclipse.ecf.core.provider.IContainerInstantiator#getSupportedParameterTypes(org.eclipse.ecf.core.ContainerTypeDescription)
>+	 */
>+	public Class[][] getSupportedParameterTypes(ContainerTypeDescription description) {
>+		return new Class[0][0];
>+	}
>+
>+}

Actions: View | Diff

Attachments on bug 200803: 77967 | 79065