Attachment #79065 for bug #200803

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

Lines 15-18 Link Here

(-)META-INF/MANIFEST.MF (-1 / +2 lines)
15	J2SE-1.3	15	J2SE-1.3
16	Require-Bundle: org.eclipse.equinox.common,	16	Require-Bundle: org.eclipse.equinox.common,
17	org.eclipse.ecf	17	org.eclipse.ecf
18	Import-Package: org.osgi.framework;version="1.3.0"	18	Import-Package: org.eclipse.osgi.util;version="1.1.0",
		19	org.osgi.framework;version="1.3.0"

Lines 1-5 Link Here

(-)plugin.xml (+9 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<?eclipse version="3.2"?>	2	<?eclipse version="3.2"?>
3	<plugin>	3	<plugin>
		4	<extension
		5	point="org.eclipse.ecf.containerFactory">
		6	<containerFactory
		7	class="org.eclipse.ecf.internal.discovery.CompositeDiscoveryContainerInstantiator"
		8	description="Composite Discovery Container"
		9	name="ecf.discovery.*"
		10	server="true">
		11	</containerFactory>
		12	</extension>
4		13
5	</plugin>	14	</plugin>




/*******************************************************************************
 * 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);
			}
		}
	}
}




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() {
	}
}

Added Link Here

(-)src/org/eclipse/ecf/internal/discovery/messages.properties (+3 lines)
1	CompositeDiscoveryContainerInstantiator_2=Exception making Composite container
2	CompositeDiscoveryContainerInstantiator_3=Exception making Composite container
3	CompositeDiscoveryContainer_DEPRECATED=deprecated API isn't supported by CompositeContainer




/*******************************************************************************
 * 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];
	}

}

Return to bug 200803

Added Link Here

(-)src/org/eclipse/ecf/internal/discovery/CompositeDiscoveryContainer.java (+389 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 Versant Corp.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Markus Kuppe (mkuppe <at> versant <dot> com) - initial API and implementation
10	******************************************************************************/
11	package org.eclipse.ecf.internal.discovery;
12
13	import java.util.*;
14	import org.eclipse.ecf.core.*;
15	import org.eclipse.ecf.core.events.ContainerDisconnectedEvent;
16	import org.eclipse.ecf.core.events.ContainerDisconnectingEvent;
17	import org.eclipse.ecf.core.identity.*;
18	import org.eclipse.ecf.core.security.IConnectContext;
19	import org.eclipse.ecf.core.util.ECFException;
20	import org.eclipse.ecf.discovery.*;
21	import org.eclipse.ecf.discovery.identity.IServiceID;
22	import org.eclipse.ecf.discovery.identity.IServiceTypeID;
23	import org.eclipse.ecf.discovery.service.IDiscoveryService;
24
25	public class CompositeDiscoveryContainer extends AbstractContainer implements IContainer, IDiscoveryService {
26	private class CompositeContainerServiceListener implements IServiceListener {
27
28	/*
29	* (non-Javadoc)
30	*
31	* @see org.eclipse.ecf.discovery.IServiceListener#serviceAdded(org.eclipse.ecf.discovery.IServiceEvent)
32	*/
33	public void serviceAdded(IServiceEvent event) {
34	synchronized (serviceListeners) {
35	//TODO fix race condition
36	Collection col = (Collection) serviceListeners.get(event.getServiceInfo().getServiceID().getServiceTypeID());
37	if (col != null) {
38	synchronized (col) {
39	for (Iterator itr = col.iterator(); itr.hasNext();) {
40	IServiceListener isl = (IServiceListener) itr.next();
41	isl.serviceAdded(event);
42	}
43	}
44	}
45	}
46	}
47
48	/*
49	* (non-Javadoc)
50	*
51	* @see org.eclipse.ecf.discovery.IServiceListener#serviceRemoved(org.eclipse.ecf.discovery.IServiceEvent)
52	*/
53	public void serviceRemoved(IServiceEvent event) {
54	synchronized (serviceListeners) {
55	Collection col = (Collection) serviceListeners.get(event.getServiceInfo().getServiceID().getServiceTypeID());
56	if (col != null) {
57	synchronized (col) {
58	for (Iterator itr = col.iterator(); itr.hasNext();) {
59	IServiceListener isl = (IServiceListener) itr.next();
60	isl.serviceRemoved(event);
61	}
62	}
63	}
64	}
65	}
66
67	/*
68	* (non-Javadoc)
69	*
70	* @see org.eclipse.ecf.discovery.IServiceListener#serviceResolved(org.eclipse.ecf.discovery.IServiceEvent)
71	*/
72	public void serviceResolved(IServiceEvent event) {
73	synchronized (serviceListeners) {
74	Collection col = (Collection) serviceListeners.get(event.getServiceInfo().getServiceID().getServiceTypeID());
75	if (col != null) {
76	synchronized (col) {
77	for (Iterator itr = col.iterator(); itr.hasNext();) {
78	IServiceListener isl = (IServiceListener) itr.next();
79	isl.serviceResolved(event);
80	}
81	}
82	}
83	}
84	}
85	}
86
87	private class CompositeContainerServiceTypeListener implements IServiceTypeListener {
88
89	/*
90	* (non-Javadoc)
91	*
92	* @see org.eclipse.ecf.discovery.IServiceTypeListener#serviceTypeAdded(org.eclipse.ecf.discovery.IServiceEvent)
93	*/
94	public void serviceTypeAdded(IServiceEvent event) {
95	// add ourself as a listener to the underlying providers
96	IServiceTypeID istid = event.getServiceInfo().getServiceID().getServiceTypeID();
97	synchronized (containers) {
98	for (Iterator itr = containers.iterator(); itr.hasNext();) {
99	//TODO ccstl doesn't have to be a listener for a non matching (namespace) container, but it doesn't hurt either
100	IDiscoveryContainerAdapter idca = (IDiscoveryContainerAdapter) itr.next();
101	idca.addServiceListener(istid, ccsl);
102	}
103	}
104	// notify our listeners
105	synchronized (serviceTypeListeners) {
106	for (Iterator itr = serviceTypeListeners.iterator(); itr.hasNext();) {
107	IServiceTypeListener listener = (IServiceTypeListener) itr.next();
108	listener.serviceTypeAdded(event);
109	}
110	}
111	}
112	}
113
114	protected CompositeContainerServiceListener ccsl = new CompositeContainerServiceListener();
115	protected CompositeContainerServiceTypeListener ccstl = new CompositeContainerServiceTypeListener();
116
117	protected List containers = new ArrayList();
118
119	private ID id;
120
121	protected Map serviceListeners = new HashMap();
122
123	protected Collection serviceTypeListeners = new HashSet();
124
125	public CompositeDiscoveryContainer(List containers) throws IDCreateException {
126	this.containers = containers;
127	this.id = IDFactory.getDefault().createStringID(CompositeDiscoveryContainer.class.getName());
128	}
129
130	/*
131	* (non-Javadoc)
132	*
133	* @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#addServiceListener(org.eclipse.ecf.discovery.identity.IServiceTypeID,
134	* org.eclipse.ecf.discovery.IServiceListener)
135	*/
136	public void addServiceListener(IServiceTypeID type, IServiceListener listener) {
137	synchronized (serviceListeners) {
138	Collection col = (Collection) serviceListeners.get(type);
139	if (col == null) {
140	col = new HashSet();
141	serviceListeners.put(type, col);
142	}
143	col.add(listener);
144	}
145	}
146
147	/**
148	* @deprecated
149	* @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#addServiceListener(java.lang.String,
150	* org.eclipse.ecf.discovery.IServiceListener)
151	*/
152	public void addServiceListener(String type, IServiceListener listener) {
153	throw new UnsupportedOperationException(Messages.CompositeDiscoveryContainer_DEPRECATED);
154	}
155
156	/*
157	* (non-Javadoc)
158	*
159	* @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#addServiceTypeListener(org.eclipse.ecf.discovery.IServiceTypeListener)
160	*/
161	public void addServiceTypeListener(IServiceTypeListener listener) {
162	synchronized (serviceTypeListeners) {
163	serviceTypeListeners.add(listener);
164	}
165	}
166
167	/*
168	* (non-Javadoc)
169	*
170	* @see org.eclipse.ecf.core.IContainer#connect(org.eclipse.ecf.core.identity.ID,
171	* org.eclipse.ecf.core.security.IConnectContext)
172	*/
173	public void connect(ID targetID, IConnectContext connectContext) throws ContainerConnectException {
174	synchronized (containers) {
175	for (Iterator itr = containers.iterator(); itr.hasNext();) {
176	IContainer container = (IContainer) itr.next();
177	container.connect(targetID, connectContext);
178	IDiscoveryContainerAdapter idca = (IDiscoveryContainerAdapter) container;
179	idca.addServiceTypeListener(ccstl);
180	}
181	}
182	}
183
184	/*
185	* (non-Javadoc)
186	*
187	* @see org.eclipse.ecf.core.IContainer#disconnect()
188	*/
189	public void disconnect() {
190	fireContainerEvent(new ContainerDisconnectingEvent(this.getID(), getConnectedID()));
191	synchronized (containers) {
192	for (Iterator itr = containers.iterator(); itr.hasNext();) {
193	IContainer container = (IContainer) itr.next();
194	container.disconnect();
195	}
196	}
197	fireContainerEvent(new ContainerDisconnectedEvent(this.getID(), getConnectedID()));
198	}
199
200	/* (non-Javadoc)
201	* @see org.eclipse.ecf.core.AbstractContainer#dispose()
202	*/
203	public void dispose() {
204	disconnect();
205	synchronized (containers) {
206	for (Iterator itr = containers.iterator(); itr.hasNext();) {
207	IContainer container = (IContainer) itr.next();
208	container.dispose();
209	}
210	}
211	super.dispose();
212	}
213
214	/* (non-Javadoc)
215	* @see org.eclipse.ecf.core.IContainer#getConnectedID()
216	*/
217	public ID getConnectedID() {
218	return getID();
219	}
220
221	/* (non-Javadoc)
222	* @see org.eclipse.ecf.core.IContainer#getConnectNamespace()
223	*/
224	public Namespace getConnectNamespace() {
225	throw new UnsupportedOperationException("not yet implemented"); //$NON-NLS-1$
226	}
227
228	/**
229	* Get the IContainer for the given Namespace
230	* @param aNamespace
231	* @return The IDiscoveryContainerAdapter for the given Namespace
232	*/
233	private IDiscoveryContainerAdapter getContainerByNamespace(Namespace aNamespace) {
234	synchronized (containers) {
235	for (Iterator itr = containers.iterator(); itr.hasNext();) {
236	IContainer container = (IContainer) itr.next();
237	// TODO handle the case for the generic ServiceID which should work with all containers
238	// could be done by a smart equals impl or better a comparator
239	Namespace containerNamespace = container.getConnectNamespace();
240	if (containerNamespace.equals(aNamespace)) {
241	return (IDiscoveryContainerAdapter) container;
242	}
243	}
244	}
245	return null;
246	}
247
248	/*
249	* (non-Javadoc)
250	*
251	* @see org.eclipse.ecf.core.identity.IIdentifiable#getID()
252	*/
253	public ID getID() {
254	return id;
255	}
256
257	/* (non-Javadoc)
258	* @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#getServiceInfo(org.eclipse.ecf.discovery.identity.IServiceID, int)
259	*/
260	public IServiceInfo getServiceInfo(IServiceID aService, int timeout) {
261	synchronized (containers) {
262	for (Iterator itr = containers.iterator(); itr.hasNext();) {
263	IDiscoveryContainerAdapter idca = (IDiscoveryContainerAdapter) itr.next();
264	IServiceInfo service = idca.getServiceInfo(aService, timeout);
265	if (service != null) {
266	return service;
267	}
268	}
269	}
270	return null;
271	}
272
273	/* (non-Javadoc)
274	* @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#getServices(org.eclipse.ecf.discovery.identity.IServiceTypeID)
275	*/
276	public IServiceInfo[] getServices(IServiceTypeID type) {
277	Set set = new HashSet();
278	synchronized (containers) {
279	for (Iterator itr = containers.iterator(); itr.hasNext();) {
280	IDiscoveryContainerAdapter idca = (IDiscoveryContainerAdapter) itr.next();
281	IServiceInfo[] services = idca.getServices(type);
282	for (int i = 0; i < services.length; i++) {
283	set.add(services[i]);
284	}
285	}
286	}
287	return (IServiceInfo[]) set.toArray(new IServiceInfo[set.size()]);
288	}
289
290	/**
291	* @deprecated
292	* @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#getServices(java.lang.String)
293	*/
294	public IServiceInfo[] getServices(String type) {
295	throw new UnsupportedOperationException(Messages.CompositeDiscoveryContainer_DEPRECATED);
296	}
297
298	/* (non-Javadoc)
299	* @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#getServicesNamespace()
300	*/
301	public Namespace getServicesNamespace() {
302	throw new UnsupportedOperationException("not yet implemented"); //$NON-NLS-1$
303	}
304
305	/* (non-Javadoc)
306	* @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#registerService(org.eclipse.ecf.discovery.IServiceInfo)
307	*/
308	public void registerService(IServiceInfo serviceInfo) throws ECFException {
309	IDiscoveryContainerAdapter idca = getContainerByNamespace(serviceInfo.getServiceID().getNamespace());
310	if (idca != null) {
311	idca.registerService(serviceInfo);
312	}
313	}
314
315	/* (non-Javadoc)
316	* @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#registerServiceType(org.eclipse.ecf.discovery.identity.IServiceTypeID)
317	*/
318	public void registerServiceType(IServiceTypeID type) {
319	IDiscoveryContainerAdapter idca = getContainerByNamespace(type.getNamespace());
320	if (idca != null) {
321	idca.registerServiceType(type);
322	}
323	}
324
325	/**
326	* @deprecated
327	* @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#registerServiceType(java.lang.String)
328	*/
329	public void registerServiceType(String serviceType) {
330	throw new UnsupportedOperationException(Messages.CompositeDiscoveryContainer_DEPRECATED);
331	}
332
333	/*
334	* (non-Javadoc)
335	*
336	* @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#removeServiceListener(org.eclipse.ecf.discovery.identity.IServiceTypeID,
337	* org.eclipse.ecf.discovery.IServiceListener)
338	*/
339	public void removeServiceListener(IServiceTypeID type, IServiceListener listener) {
340	synchronized (serviceListeners) {
341	Collection col = (Collection) serviceListeners.get(type);
342	synchronized (col) {
343	col.remove(listener);
344	}
345	}
346	}
347
348	/**
349	* @deprecated
350	* @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#removeServiceListener(java.lang.String,
351	* org.eclipse.ecf.discovery.IServiceListener)
352	*/
353	public void removeServiceListener(String type, IServiceListener listener) {
354	throw new UnsupportedOperationException(Messages.CompositeDiscoveryContainer_DEPRECATED);
355	}
356
357	/*
358	* (non-Javadoc)
359	*
360	* @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#removeServiceTypeListener(org.eclipse.ecf.discovery.IServiceTypeListener)
361	*/
362	public void removeServiceTypeListener(IServiceTypeListener listener) {
363	synchronized (serviceTypeListeners) {
364	serviceTypeListeners.remove(listener);
365	}
366	}
367
368	/* (non-Javadoc)
369	* @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#requestServiceInfo(org.eclipse.ecf.discovery.identity.IServiceID, int)
370	*/
371	public void requestServiceInfo(IServiceID service, int timeout) {
372	IDiscoveryContainerAdapter idca = getContainerByNamespace(service.getNamespace());
373	if (idca != null) {
374	idca.requestServiceInfo(service, timeout);
375	}
376	}
377
378	/* (non-Javadoc)
379	* @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#unregisterService(org.eclipse.ecf.discovery.IServiceInfo)
380	*/
381	public void unregisterService(IServiceInfo serviceInfo) {
382	synchronized (containers) {
383	for (Iterator itr = containers.iterator(); itr.hasNext();) {
384	IDiscoveryContainerAdapter idca = (IDiscoveryContainerAdapter) itr.next();
385	idca.unregisterService(serviceInfo);
386	}
387	}
388	}
389	}

Added Link Here

(-)src/org/eclipse/ecf/internal/discovery/Messages.java (+17 lines)
1	package org.eclipse.ecf.internal.discovery;
2
3	import org.eclipse.osgi.util.NLS;
4
5	public class Messages extends NLS {
6	private static final String BUNDLE_NAME = "org.eclipse.ecf.internal.discovery.messages"; //$NON-NLS-1$
7	public static String CompositeDiscoveryContainer_DEPRECATED;
8	public static String CompositeDiscoveryContainerInstantiator_2;
9	public static String CompositeDiscoveryContainerInstantiator_3;
10	static {
11	// initialize resource bundle
12	NLS.initializeMessages(BUNDLE_NAME, Messages.class);
13	}
14
15	private Messages() {
16	}
17	}