WIP - bug 328011: Use OSGi whiteboard pattern for IServiceListener|IServiceTypeListener registration

https://bugs.eclipse.org/bugs/show_bug.cgi?id=328011

4 files changed, 320 insertions, 46 deletions

diff --git a/framework/bundles/org.eclipse.ecf.discovery/src/org/eclipse/ecf/discovery/AbstractDiscoveryContainerAdapter.java b/framework/bundles/org.eclipse.ecf.discovery/src/org/eclipse/ecf/discovery/AbstractDiscoveryContainerAdapter.java
index 3e76922ec..96e664f34 100644
--- a/framework/bundles/org.eclipse.ecf.discovery/src/org/eclipse/ecf/discovery/AbstractDiscoveryContainerAdapter.java
+++ b/framework/bundles/org.eclipse.ecf.discovery/src/org/eclipse/ecf/discovery/AbstractDiscoveryContainerAdapter.java
@@ -10,6 +10,12 @@
  ******************************************************************************/
 package org.eclipse.ecf.discovery;
 
+import org.eclipse.ecf.internal.discovery.ServiceTypeComparator;
+
+import java.util.Iterator;
+
+import org.eclipse.ecf.internal.discovery.DiscoveryServiceListener;
+
 import java.util.*;
 import org.eclipse.core.runtime.Assert;
 import org.eclipse.core.runtime.IProgressMonitor;
@@ -26,30 +32,38 @@ public abstract class AbstractDiscoveryContainerAdapter extends
 		AbstractContainer implements IDiscoveryLocator, IDiscoveryAdvertiser {
 
 	/**
-	 * Collection of service listeners i.e. Collection<IServiceListener>.
-	 * NOTE: Access to this collection is synchronized, so subclasses should take this into account.
+	 * Collection of service listeners i.e. Collection<IServiceListener>. NOTE:
+	 * Access to this collection is synchronized, so subclasses should take this
+	 * into account.
 	 */
 	protected final Set allServiceListeners;
 
 	private DiscoveryContainerConfig config;
 
 	/**
-	 * Map of service type to collection of service listeners i.e. <String,Collection<IServiceListener>>.
-	 * NOTE: Access to this map is synchronized, so subclasses should take this into account.
+	 * Map of service type to collection of service listeners i.e.
+	 * <String,Collection<IServiceListener>>. NOTE: Access to this map is
+	 * synchronized, so subclasses should take this into account.
 	 */
 	protected final Map serviceListeners;
 	protected final String servicesNamespaceName;
 	/**
-	 * Collection of service type listeners i.e. Collection<IServiceTypeListener>.
-	 * NOTE: Access to this collection is synchronized, so subclasses should take this into account.
+	 * Collection of service type listeners i.e.
+	 * Collection<IServiceTypeListener>. NOTE: Access to this collection is
+	 * synchronized, so subclasses should take this into account.
 	 */
 	protected final Collection serviceTypeListeners;
 
+	private DiscoveryServiceListener discoveryServiceListener;
+	private DiscoveryServiceListener discoveryServiceTypeListener;
+	private ServiceTypeComparator discoveryServiceListenerComparator;
+
 	/**
 	 * @param aNamespaceName
 	 * @param aConfig
 	 */
-	public AbstractDiscoveryContainerAdapter(String aNamespaceName, DiscoveryContainerConfig aConfig) {
+	public AbstractDiscoveryContainerAdapter(String aNamespaceName,
+			DiscoveryContainerConfig aConfig) {
 		servicesNamespaceName = aNamespaceName;
 		Assert.isNotNull(servicesNamespaceName);
 		config = aConfig;
@@ -57,20 +71,37 @@ public abstract class AbstractDiscoveryContainerAdapter extends
 		serviceTypeListeners = Collections.synchronizedSet(new HashSet());
 		serviceListeners = Collections.synchronizedMap(new HashMap());
 		allServiceListeners = Collections.synchronizedSet(new HashSet());
+
+		discoveryServiceListener = new DiscoveryServiceListener(this,
+				IServiceListener.class);
+		discoveryServiceTypeListener = new DiscoveryServiceListener(this,
+				IServiceTypeListener.class);
+
+		discoveryServiceListenerComparator = new ServiceTypeComparator();
 	}
 
-	/* (non-Javadoc)
-	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#addServiceListener(org.eclipse.ecf.discovery.IServiceListener)
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#addServiceListener
+	 * (org.eclipse.ecf.discovery.IServiceListener)
 	 */
 	public void addServiceListener(IServiceListener aListener) {
 		Assert.isNotNull(aListener);
 		allServiceListeners.add(aListener);
 	}
 
-	/* (non-Javadoc)
-	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#addServiceListener(org.eclipse.ecf.discovery.identity.IServiceTypeID, org.eclipse.ecf.discovery.IServiceListener)
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#addServiceListener
+	 * (org.eclipse.ecf.discovery.identity.IServiceTypeID,
+	 * org.eclipse.ecf.discovery.IServiceListener)
 	 */
-	public void addServiceListener(IServiceTypeID aType, IServiceListener aListener) {
+	public void addServiceListener(IServiceTypeID aType,
+			IServiceListener aListener) {
 		Assert.isNotNull(aListener);
 		Assert.isNotNull(aType);
 		synchronized (serviceListeners) { // put-if-absent idiom race condition
@@ -83,8 +114,12 @@ public abstract class AbstractDiscoveryContainerAdapter extends
 		}
 	}
 
-	/* (non-Javadoc)
-	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#addServiceTypeListener(org.eclipse.ecf.discovery.IServiceTypeListener)
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#addServiceTypeListener
+	 * (org.eclipse.ecf.discovery.IServiceTypeListener)
 	 */
 	public void addServiceTypeListener(IServiceTypeListener aListener) {
 		Assert.isNotNull(aListener);
@@ -97,35 +132,49 @@ public abstract class AbstractDiscoveryContainerAdapter extends
 		allServiceListeners.clear();
 	}
 
-	/* (non-Javadoc)
+	/*
+	 * (non-Javadoc)
+	 * 
 	 * @see org.eclipse.ecf.core.AbstractContainer#dispose()
 	 */
 	public void dispose() {
 		disconnect();
 		clearListeners();
 		config = null;
+		discoveryServiceListener.dispose();
+		discoveryServiceTypeListener.dispose();
 		super.dispose();
 	}
 
 	/**
-	 * Calls {@link IServiceListener#serviceDiscovered(IServiceEvent)} for all registered {@link IServiceListener}
-	 * @param aServiceEvent The {@link IServiceEvent} to send along the call
+	 * Calls {@link IServiceListener#serviceDiscovered(IServiceEvent)} for all
+	 * registered {@link IServiceListener}
+	 * 
+	 * @param aServiceEvent
+	 *            The {@link IServiceEvent} to send along the call
 	 */
 	protected void fireServiceDiscovered(IServiceEvent aServiceEvent) {
 		Assert.isNotNull(aServiceEvent);
-		final Collection listeners = getListeners(aServiceEvent.getServiceInfo().getServiceID().getServiceTypeID());
+		final Collection listeners = getListeners(aServiceEvent
+				.getServiceInfo().getServiceID().getServiceTypeID());
 		if (listeners != null) {
 			for (final Iterator i = listeners.iterator(); i.hasNext();) {
 				final IServiceListener l = (IServiceListener) i.next();
 				l.serviceDiscovered(aServiceEvent);
-				Trace.trace(DiscoveryPlugin.PLUGIN_ID, DiscoveryDebugOption.METHODS_TRACING, this.getClass(), "fireServiceDiscovered", aServiceEvent.toString()); //$NON-NLS-1$
+				Trace.trace(DiscoveryPlugin.PLUGIN_ID,
+						DiscoveryDebugOption.METHODS_TRACING, this.getClass(),
+						"fireServiceDiscovered", aServiceEvent.toString()); //$NON-NLS-1$
 			}
 		}
 	}
 
 	/**
-	 * Calls {@link IServiceTypeListener#serviceTypeDiscovered(IServiceTypeEvent)} for all registered {@link IServiceTypeListener}
-	 * @param aServiceTypeEvent The {@link IServiceTypeEvent} to send along the call
+	 * Calls
+	 * {@link IServiceTypeListener#serviceTypeDiscovered(IServiceTypeEvent)} for
+	 * all registered {@link IServiceTypeListener}
+	 * 
+	 * @param aServiceTypeEvent
+	 *            The {@link IServiceTypeEvent} to send along the call
 	 */
 	protected void fireServiceTypeDiscovered(IServiceTypeEvent aServiceTypeEvent) {
 		Assert.isNotNull(aServiceTypeEvent);
@@ -136,41 +185,54 @@ public abstract class AbstractDiscoveryContainerAdapter extends
 		for (final Iterator i = notify.iterator(); i.hasNext();) {
 			final IServiceTypeListener l = (IServiceTypeListener) i.next();
 			l.serviceTypeDiscovered(aServiceTypeEvent);
-			Trace.trace(DiscoveryPlugin.PLUGIN_ID, DiscoveryDebugOption.METHODS_TRACING, this.getClass(), "fireServiceTypeDiscovered", aServiceTypeEvent.toString()); //$NON-NLS-1$
+			Trace.trace(DiscoveryPlugin.PLUGIN_ID,
+					DiscoveryDebugOption.METHODS_TRACING, this.getClass(),
+					"fireServiceTypeDiscovered", aServiceTypeEvent.toString()); //$NON-NLS-1$
 		}
 	}
 
 	/**
-	 * Calls {@link IServiceListener#serviceUndiscovered(IServiceEvent)} for all registered {@link IServiceListener}
-	 * @param aServiceEvent The {@link IServiceEvent} to send along the call
+	 * Calls {@link IServiceListener#serviceUndiscovered(IServiceEvent)} for all
+	 * registered {@link IServiceListener}
+	 * 
+	 * @param aServiceEvent
+	 *            The {@link IServiceEvent} to send along the call
 	 */
 	protected void fireServiceUndiscovered(IServiceEvent aServiceEvent) {
 		Assert.isNotNull(aServiceEvent);
-		final Collection listeners = getListeners(aServiceEvent.getServiceInfo().getServiceID().getServiceTypeID());
+		final Collection listeners = getListeners(aServiceEvent
+				.getServiceInfo().getServiceID().getServiceTypeID());
 		if (listeners != null) {
 			for (final Iterator i = listeners.iterator(); i.hasNext();) {
 				final IServiceListener l = (IServiceListener) i.next();
 				l.serviceUndiscovered(aServiceEvent);
-				Trace.trace(DiscoveryPlugin.PLUGIN_ID, DiscoveryDebugOption.METHODS_TRACING, this.getClass(), "fireServiceUndiscovered", aServiceEvent.toString()); //$NON-NLS-1$
+				Trace.trace(DiscoveryPlugin.PLUGIN_ID,
+						DiscoveryDebugOption.METHODS_TRACING, this.getClass(),
+						"fireServiceUndiscovered", aServiceEvent.toString()); //$NON-NLS-1$
 			}
 		}
 	}
 
 	/**
-	 * @return The {@link DiscoveryContainerConfig} of this {@link IDiscoveryContainerAdapter}
+	 * @return The {@link DiscoveryContainerConfig} of this
+	 *         {@link IDiscoveryContainerAdapter}
 	 */
 	protected DiscoveryContainerConfig getConfig() {
 		return config;
 	}
 
-	/* (non-Javadoc)
+	/*
+	 * (non-Javadoc)
+	 * 
 	 * @see org.eclipse.ecf.core.IContainer#getConnectNamespace()
 	 */
 	public Namespace getConnectNamespace() {
 		return IDFactory.getDefault().getNamespaceByName(servicesNamespaceName);
 	}
 
-	/* (non-Javadoc)
+	/*
+	 * (non-Javadoc)
+	 * 
 	 * @see org.eclipse.ecf.core.identity.IIdentifiable#getID()
 	 */
 	public ID getID() {
@@ -180,21 +242,34 @@ public abstract class AbstractDiscoveryContainerAdapter extends
 		return null;
 	}
 
-	// merges the allServiceListener with the serviceListeners for the given type
+	// merges the allServiceListener with the serviceListeners for the given
+	// type
 
 	/**
-	 * Joins the {@link Collection} of {@link IServiceListener}s interested in any {@link IServiceTypeID} with
-	 * the {@link Collection} of the {@link IServiceListener} registered for the given {@link IServiceTypeID}
-	 * @param aServiceType The {@link IServiceTypeID} for which the {@link IServiceListener}s are returned
-	 * @return All {@link IServiceListener}s interested in the given {@link IServiceTypeID}
+	 * Joins the {@link Collection} of {@link IServiceListener}s interested in
+	 * any {@link IServiceTypeID} with the {@link Collection} of the
+	 * {@link IServiceListener} registered for the given {@link IServiceTypeID}
+	 * 
+	 * @param aServiceType
+	 *            The {@link IServiceTypeID} for which the
+	 *            {@link IServiceListener}s are returned
+	 * @return All {@link IServiceListener}s interested in the given
+	 *         {@link IServiceTypeID}
 	 */
 	protected Collection getListeners(IServiceTypeID aServiceType) {
 		Assert.isNotNull(aServiceType);
 		Collection listeners = new HashSet();
 		synchronized (serviceListeners) {
-			Collection collection = (Collection) serviceListeners.get(aServiceType);
-			if (collection != null) {
-				listeners.addAll(collection);
+			for (Iterator itr = serviceListeners.keySet().iterator(); itr.hasNext();) {
+				IServiceTypeID typeID = (IServiceTypeID) itr.next();
+				int compare = discoveryServiceListenerComparator.compare(aServiceType, typeID);
+				if(compare == 0) {
+					Collection collection = (Collection) serviceListeners
+					.get(aServiceType);
+					if (collection != null) {
+						listeners.addAll(collection);
+					}
+				}
 			}
 		}
 		synchronized (allServiceListeners) {
@@ -203,25 +278,39 @@ public abstract class AbstractDiscoveryContainerAdapter extends
 		return Collections.unmodifiableCollection(listeners);
 	}
 
-	/* (non-Javadoc)
-	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#getServicesNamespace()
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#getServicesNamespace
+	 * ()
 	 */
 	public Namespace getServicesNamespace() {
 		return IDFactory.getDefault().getNamespaceByName(servicesNamespaceName);
 	}
 
-	/* (non-Javadoc)
-	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#removeServiceListener(org.eclipse.ecf.discovery.IServiceListener)
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#removeServiceListener
+	 * (org.eclipse.ecf.discovery.IServiceListener)
 	 */
 	public void removeServiceListener(IServiceListener aListener) {
 		Assert.isNotNull(aListener);
 		allServiceListeners.remove(aListener);
 	}
 
-	/* (non-Javadoc)
-	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#removeServiceListener(org.eclipse.ecf.discovery.identity.IServiceTypeID, org.eclipse.ecf.discovery.IServiceListener)
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#removeServiceListener
+	 * (org.eclipse.ecf.discovery.identity.IServiceTypeID,
+	 * org.eclipse.ecf.discovery.IServiceListener)
 	 */
-	public void removeServiceListener(IServiceTypeID aType, IServiceListener aListener) {
+	public void removeServiceListener(IServiceTypeID aType,
+			IServiceListener aListener) {
 		Assert.isNotNull(aListener);
 		Assert.isNotNull(aType);
 		synchronized (serviceListeners) {
@@ -232,8 +321,11 @@ public abstract class AbstractDiscoveryContainerAdapter extends
 		}
 	}
 
-	/* (non-Javadoc)
-	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#removeServiceTypeListener(org.eclipse.ecf.discovery.IServiceTypeListener)
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#
+	 * removeServiceTypeListener(org.eclipse.ecf.discovery.IServiceTypeListener)
 	 */
 	public void removeServiceTypeListener(IServiceTypeListener aListener) {
 		Assert.isNotNull(aListener);
diff --git a/framework/bundles/org.eclipse.ecf.discovery/src/org/eclipse/ecf/internal/discovery/DiscoveryPlugin.java b/framework/bundles/org.eclipse.ecf.discovery/src/org/eclipse/ecf/internal/discovery/DiscoveryPlugin.java
index 1179e46c5..bea3f881b 100644
--- a/framework/bundles/org.eclipse.ecf.discovery/src/org/eclipse/ecf/internal/discovery/DiscoveryPlugin.java
+++ b/framework/bundles/org.eclipse.ecf.discovery/src/org/eclipse/ecf/internal/discovery/DiscoveryPlugin.java
@@ -109,4 +109,7 @@ public class DiscoveryPlugin implements BundleActivator {
 		return plugin;
 	}
 
+	public BundleContext getBundleContext() {
+		return context;
+	}
 }
diff --git a/framework/bundles/org.eclipse.ecf.discovery/src/org/eclipse/ecf/internal/discovery/DiscoveryServiceListener.java b/framework/bundles/org.eclipse.ecf.discovery/src/org/eclipse/ecf/internal/discovery/DiscoveryServiceListener.java
new file mode 100644
index 000000000..617f8ea68
--- /dev/null
+++ b/framework/bundles/org.eclipse.ecf.discovery/src/org/eclipse/ecf/internal/discovery/DiscoveryServiceListener.java
@@ -0,0 +1,127 @@
+/**
+ * 
+ */
+package org.eclipse.ecf.internal.discovery;
+
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.ecf.core.identity.IDFactory;
+import org.eclipse.ecf.core.identity.Namespace;
+import org.eclipse.ecf.discovery.*;
+import org.eclipse.ecf.discovery.identity.IServiceTypeID;
+import org.osgi.framework.*;
+
+public class DiscoveryServiceListener implements ServiceListener {
+
+	private AbstractDiscoveryContainerAdapter discoveryContainer;
+	private BundleContext context;
+	private Class listenerClass;
+
+	public DiscoveryServiceListener(
+			AbstractDiscoveryContainerAdapter anAbstractDiscoveryContainerAdapter,
+			Class clazz) {
+		discoveryContainer = anAbstractDiscoveryContainerAdapter;
+		listenerClass = clazz;
+		context = DiscoveryPlugin.getDefault().getBundleContext();
+		try {
+			// get existing listener
+			ServiceReference[] references = context.getServiceReferences(
+					listenerClass.getName(), null);
+			addServiceListener(references);
+
+			// listen for more listeners
+			context.addServiceListener(this, getFilter());
+		} catch (InvalidSyntaxException e) {
+			DiscoveryPlugin.getDefault().log(
+					new Status(IStatus.ERROR, DiscoveryPlugin.PLUGIN_ID,
+							IStatus.ERROR, "Cannot create filter", e)); //$NON-NLS-1$
+		}
+	}
+
+	public void dispose() {
+		context.removeServiceListener(this);
+	}
+
+	private void addServiceListener(ServiceReference[] references) {
+		for (int i = 0; i < references.length; i++) {
+			ServiceReference serviceReference = references[i];
+			if (listenerClass.getName()
+					.equals(IServiceListener.class.getName())) {
+				IServiceTypeID aType = getIServiceTypeID(serviceReference);
+				IServiceListener aListener = (IServiceListener) context
+						.getService(serviceReference);
+				discoveryContainer.addServiceListener(aType, aListener);
+			} else {
+				IServiceTypeListener aListener = (IServiceTypeListener) context
+						.getService(serviceReference);
+				discoveryContainer.addServiceTypeListener(aListener);
+			}
+		}
+	}
+
+	private void addServiceListener(ServiceReference reference) {
+		addServiceListener(new ServiceReference[] { reference });
+	}
+
+	private void removeServiceListener(ServiceReference[] references) {
+		for (int i = 0; i < references.length; i++) {
+			ServiceReference serviceReference = references[i];
+			if (listenerClass.getName()
+					.equals(IServiceListener.class.getName())) {
+				IServiceTypeID aType = getIServiceTypeID(serviceReference);
+				IServiceListener aListener = (IServiceListener) context
+						.getService(serviceReference);
+				discoveryContainer.removeServiceListener(aType, aListener);
+			} else {
+				IServiceTypeListener aListener = (IServiceTypeListener) context
+						.getService(serviceReference);
+				discoveryContainer.removeServiceTypeListener(aListener);
+			}
+		}
+	}
+
+	private void removeServiceListener(ServiceReference reference) {
+		removeServiceListener(new ServiceReference[] { reference });
+	}
+
+	private IServiceTypeID getIServiceTypeID(ServiceReference serviceReference) {
+		Namespace namespace = discoveryContainer.getServicesNamespace();
+		String services = (String) serviceReference
+				.getProperty("org.eclipse.ecf.discovery.services");
+		String scopes = (String) serviceReference
+				.getProperty("org.eclipse.ecf.discovery.scopes");
+		String protocols = (String) serviceReference
+				.getProperty("org.eclipse.ecf.discovery.protocols");
+		String namingAuthority = (String) serviceReference
+				.getProperty("org.eclipse.ecf.discovery.namingauthority");
+		return (IServiceTypeID) IDFactory.getDefault().createID(
+				namespace,
+				"_" + services + "" + protocols + "" + scopes + ""
+						+ namingAuthority);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * org.osgi.framework.ServiceListener#serviceChanged(org.osgi.framework.
+	 * ServiceEvent)
+	 */
+	public void serviceChanged(ServiceEvent event) {
+		switch (event.getType()) {
+		case ServiceEvent.REGISTERED:
+			addServiceListener(event.getServiceReference());
+			break;
+		case ServiceEvent.UNREGISTERING:
+			removeServiceListener(event.getServiceReference());
+			break;
+		default:
+			break;
+		}
+	}
+
+	private String getFilter() {
+		return "(" + Constants.OBJECTCLASS + "=" + listenerClass.getName()
+				+ ")";
+	}
+}
diff --git a/framework/bundles/org.eclipse.ecf.discovery/src/org/eclipse/ecf/internal/discovery/ServiceTypeComparator.java b/framework/bundles/org.eclipse.ecf.discovery/src/org/eclipse/ecf/internal/discovery/ServiceTypeComparator.java
new file mode 100644
index 000000000..e357a8f99
--- /dev/null
+++ b/framework/bundles/org.eclipse.ecf.discovery/src/org/eclipse/ecf/internal/discovery/ServiceTypeComparator.java
@@ -0,0 +1,52 @@
+package org.eclipse.ecf.internal.discovery;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import org.eclipse.ecf.discovery.identity.IServiceTypeID;
+
+public class ServiceTypeComparator implements Comparator {
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
+	 */
+	public int compare(Object object1, Object object2) {
+		if (object1 instanceof IServiceTypeID
+				&& object2 instanceof IServiceTypeID) {
+			IServiceTypeID type1 = (IServiceTypeID) object1;
+			IServiceTypeID type2 = (IServiceTypeID) object2;
+
+			String name1 = type1.getNamingAuthority();
+			String name2 = type2.getNamingAuthority();
+			if (!name1.equals("*") || !name2.equals("*")
+					|| !name1.equals(name2)) {
+				return -1;
+			}
+
+			String[] services1 = type1.getServices();
+			String[] services2 = type2.getServices();
+			if (!services1[0].equals("*") || !services2[0].equals("*")
+					|| !Arrays.equals(services1, services2)) {
+				return -1;
+			}
+
+			String[] protocols1 = type1.getProtocols();
+			String[] protocols2 = type2.getProtocols();
+			if (!protocols1[0].equals("*") || !protocols2[0].equals("*")
+					|| !Arrays.equals(protocols1, protocols2)) {
+				return -1;
+			}
+
+			String[] scopes1 = type1.getScopes();
+			String[] scopes2 = type2.getScopes();
+			if (!scopes1[0].equals("*") || !scopes2[0].equals("*")
+					|| !Arrays.equals(scopes1, scopes2)) {
+				return -1;
+			}
+			return 0;
+		}
+		return -1;
+	}
+
+}