felix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ma...@apache.org
Subject svn commit: r616813 [9/9] - in /felix/trunk/deploymentadmin: ./ src/ src/main/ src/main/java/ src/main/java/org/ src/main/java/org/apache/ src/main/java/org/apache/felix/ src/main/java/org/apache/felix/deploymentadmin/ src/main/java/org/apache/felix/de...
Date Wed, 30 Jan 2008 16:46:39 GMT
Added: felix/trunk/deploymentadmin/src/main/java/org/osgi/util/tracker/ServiceTracker.java
URL: http://svn.apache.org/viewvc/felix/trunk/deploymentadmin/src/main/java/org/osgi/util/tracker/ServiceTracker.java?rev=616813&view=auto
==============================================================================
--- felix/trunk/deploymentadmin/src/main/java/org/osgi/util/tracker/ServiceTracker.java (added)
+++ felix/trunk/deploymentadmin/src/main/java/org/osgi/util/tracker/ServiceTracker.java Wed Jan 30 08:46:24 2008
@@ -0,0 +1,1141 @@
+/*
+ * $Header: /cvshome/build/org.osgi.util.tracker/src/org/osgi/util/tracker/ServiceTracker.java,v 1.21 2006/07/12 21:05:17 hargrave Exp $
+ * 
+ * Copyright (c) OSGi Alliance (2000, 2006). All Rights Reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.osgi.util.tracker;
+
+import java.util.*;
+
+import org.osgi.framework.*;
+
+/**
+ * The <code>ServiceTracker</code> class simplifies using services from the
+ * Framework's service registry.
+ * <p>
+ * A <code>ServiceTracker</code> object is constructed with search criteria
+ * and a <code>ServiceTrackerCustomizer</code> object. A
+ * <code>ServiceTracker</code> object can use the
+ * <code>ServiceTrackerCustomizer</code> object to customize the service
+ * objects to be tracked. The <code>ServiceTracker</code> object can then be
+ * opened to begin tracking all services in the Framework's service registry
+ * that match the specified search criteria. The <code>ServiceTracker</code>
+ * object correctly handles all of the details of listening to
+ * <code>ServiceEvent</code> objects and getting and ungetting services.
+ * <p>
+ * The <code>getServiceReferences</code> method can be called to get
+ * references to the services being tracked. The <code>getService</code> and
+ * <code>getServices</code> methods can be called to get the service objects
+ * for the tracked service.
+ * 
+ * @version $Revision: 1.21 $
+ */
+public class ServiceTracker implements ServiceTrackerCustomizer {
+	/* set this to true to compile in debug messages */
+	static final boolean				DEBUG			= false;
+	/**
+	 * Bundle context against which this <code>ServiceTracker</code> object is tracking.
+	 */
+	protected final BundleContext		context;
+	/**
+	 * Filter specifying search criteria for the services to track.
+	 * 
+	 * @since 1.1
+	 */
+	protected final Filter				filter;
+	/**
+	 * <code>ServiceTrackerCustomizer</code> object for this tracker.
+	 */
+	final ServiceTrackerCustomizer		customizer;
+	/**
+	 * Filter string for use when adding the ServiceListener. If this field is
+	 * set, then certain optimizations can be taken since we don't have a user
+	 * supplied filter.
+	 */
+	final String						listenerFilter;
+	/**
+	 * Class name to be tracked. If this field is set, then we are tracking by
+	 * class name.
+	 */
+	private final String				trackClass;
+	/**
+	 * Reference to be tracked. If this field is set, then we are tracking a
+	 * single ServiceReference.
+	 */
+	private final ServiceReference		trackReference;
+	/**
+	 * Tracked services: <code>ServiceReference</code> object -> customized
+	 * Object and <code>ServiceListener</code> object
+	 */
+	private Tracked						tracked;
+	/**
+	 * Modification count. This field is initialized to zero by open, set to -1
+	 * by close and incremented by modified.
+	 * 
+	 * This field is volatile since it is accessed by multiple threads.
+	 */
+	private volatile int				trackingCount	= -1;
+	/**
+	 * Cached ServiceReference for getServiceReference.
+	 * 
+	 * This field is volatile since it is accessed by multiple threads.
+	 */
+	private volatile ServiceReference	cachedReference;
+	/**
+	 * Cached service object for getService.
+	 * 
+	 * This field is volatile since it is accessed by multiple threads.
+	 */
+	private volatile Object				cachedService;
+
+	/**
+	 * Create a <code>ServiceTracker</code> object on the specified
+	 * <code>ServiceReference</code> object.
+	 * 
+	 * <p>
+	 * The service referenced by the specified <code>ServiceReference</code>
+	 * object will be tracked by this <code>ServiceTracker</code> object.
+	 * 
+	 * @param context <code>BundleContext</code> object against which the
+	 *        tracking is done.
+	 * @param reference <code>ServiceReference</code> object for the service
+	 *        to be tracked.
+	 * @param customizer The customizer object to call when services are added,
+	 *        modified, or removed in this <code>ServiceTracker</code> object.
+	 *        If customizer is <code>null</code>, then this
+	 *        <code>ServiceTracker</code> object will be used as the
+	 *        <code>ServiceTrackerCustomizer</code> object and the
+	 *        <code>ServiceTracker</code> object will call the
+	 *        <code>ServiceTrackerCustomizer</code> methods on itself.
+	 */
+	public ServiceTracker(BundleContext context, ServiceReference reference,
+			ServiceTrackerCustomizer customizer) {
+		this.context = context;
+		this.trackReference = reference;
+		this.trackClass = null;
+		this.customizer = (customizer == null) ? this : customizer;
+		this.listenerFilter = "(" + Constants.SERVICE_ID + "=" + reference.getProperty(Constants.SERVICE_ID).toString() + ")"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+		try {
+			this.filter = context.createFilter(listenerFilter);
+		}
+		catch (InvalidSyntaxException e) { // we could only get this exception
+			// if the ServiceReference was
+			// invalid
+			throw new IllegalArgumentException(
+					"unexpected InvalidSyntaxException: " + e.getMessage()); //$NON-NLS-1$
+		}
+	}
+
+	/**
+	 * Create a <code>ServiceTracker</code> object on the specified class
+	 * name.
+	 * 
+	 * <p>
+	 * Services registered under the specified class name will be tracked by
+	 * this <code>ServiceTracker</code> object.
+	 * 
+	 * @param context <code>BundleContext</code> object against which the
+	 *        tracking is done.
+	 * @param clazz Class name of the services to be tracked.
+	 * @param customizer The customizer object to call when services are added,
+	 *        modified, or removed in this <code>ServiceTracker</code> object.
+	 *        If customizer is <code>null</code>, then this
+	 *        <code>ServiceTracker</code> object will be used as the
+	 *        <code>ServiceTrackerCustomizer</code> object and the
+	 *        <code>ServiceTracker</code> object will call the
+	 *        <code>ServiceTrackerCustomizer</code> methods on itself.
+	 */
+	public ServiceTracker(BundleContext context, String clazz,
+			ServiceTrackerCustomizer customizer) {
+		this.context = context;
+		this.trackReference = null;
+		this.trackClass = clazz;
+		this.customizer = (customizer == null) ? this : customizer;
+		this.listenerFilter = "(" + Constants.OBJECTCLASS + "=" + clazz.toString() + ")"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+		try {
+			this.filter = context.createFilter(listenerFilter);
+		}
+		catch (InvalidSyntaxException e) { // we could only get this exception
+			// if the clazz argument was
+			// malformed
+			throw new IllegalArgumentException(
+					"unexpected InvalidSyntaxException: " + e.getMessage()); //$NON-NLS-1$
+		}
+	}
+
+	/**
+	 * Create a <code>ServiceTracker</code> object on the specified
+	 * <code>Filter</code> object.
+	 * 
+	 * <p>
+	 * Services which match the specified <code>Filter</code> object will be
+	 * tracked by this <code>ServiceTracker</code> object.
+	 * 
+	 * @param context <code>BundleContext</code> object against which the
+	 *        tracking is done.
+	 * @param filter <code>Filter</code> object to select the services to be
+	 *        tracked.
+	 * @param customizer The customizer object to call when services are added,
+	 *        modified, or removed in this <code>ServiceTracker</code> object.
+	 *        If customizer is null, then this <code>ServiceTracker</code>
+	 *        object will be used as the <code>ServiceTrackerCustomizer</code>
+	 *        object and the <code>ServiceTracker</code> object will call the
+	 *        <code>ServiceTrackerCustomizer</code> methods on itself.
+	 * @since 1.1
+	 */
+	public ServiceTracker(BundleContext context, Filter filter,
+			ServiceTrackerCustomizer customizer) {
+		this.context = context;
+		this.trackReference = null;
+		this.trackClass = null;
+		this.listenerFilter = null;
+		this.filter = filter;
+		this.customizer = (customizer == null) ? this : customizer;
+		if ((context == null) || (filter == null)) { // we throw a NPE here
+			// to
+			// be consistent with the
+			// other constructors
+			throw new NullPointerException();
+		}
+	}
+
+	/**
+	 * Open this <code>ServiceTracker</code> object and begin tracking
+	 * services.
+	 * 
+	 * <p>
+	 * This method calls <code>open(false)</code>.
+	 * 
+	 * @throws java.lang.IllegalStateException if the <code>BundleContext</code>
+	 *         object with which this <code>ServiceTracker</code> object was
+	 *         created is no longer valid.
+	 * @see #open(boolean)
+	 */
+	public void open() {
+		open(false);
+	}
+
+	/**
+	 * Open this <code>ServiceTracker</code> object and begin tracking
+	 * services.
+	 * 
+	 * <p>
+	 * Services which match the search criteria specified when this
+	 * <code>ServiceTracker</code> object was created are now tracked by this
+	 * <code>ServiceTracker</code> object.
+	 * 
+	 * @param trackAllServices If <code>true</code>, then this
+	 *        <code>ServiceTracker</code> will track all matching services
+	 *        regardless of class loader accessibility. If <code>false</code>,
+	 *        then this <code>ServiceTracker</code> will only track matching
+	 *        services which are class loader accessibile to the bundle whose
+	 *        <code>BundleContext</code> is used by this
+	 *        <code>ServiceTracker</code>.
+	 * @throws java.lang.IllegalStateException if the <code>BundleContext</code>
+	 *         object with which this <code>ServiceTracker</code> object was
+	 *         created is no longer valid.
+	 * @since 1.3
+	 */
+	public synchronized void open(boolean trackAllServices) {
+		if (tracked != null) {
+			return;
+		}
+		if (DEBUG) {
+			System.out.println("ServiceTracker.open: " + filter); //$NON-NLS-1$
+		}
+		tracked = trackAllServices ? new AllTracked() : new Tracked();
+		trackingCount = 0;
+		synchronized (tracked) {
+			try {
+				context.addServiceListener(tracked, listenerFilter);
+				ServiceReference[] references;
+				if (listenerFilter == null) { // user supplied filter
+					references = getInitialReferences(trackAllServices, null,
+							filter.toString());
+				}
+				else { // constructor supplied filter
+					if (trackClass == null) {
+						references = new ServiceReference[] {trackReference};
+					}
+					else {
+						references = getInitialReferences(trackAllServices,
+								trackClass, null);
+					}
+				}
+
+				tracked.setInitialServices(references); // set tracked with
+				// the initial
+				// references
+			}
+			catch (InvalidSyntaxException e) {
+				throw new RuntimeException(
+						"unexpected InvalidSyntaxException: " + e.getMessage()); //$NON-NLS-1$
+			}
+		}
+		/* Call tracked outside of synchronized region */
+		tracked.trackInitialServices(); // process the initial references
+	}
+
+	/**
+	 * Returns the list of initial <code>ServiceReference</code> objects that
+	 * will be tracked by this <code>ServiceTracker</code> object.
+	 * 
+	 * @param trackAllServices If true, use getAllServiceReferences.
+	 * @param trackClass the class name with which the service was registered,
+	 *        or null for all services.
+	 * @param filterString the filter criteria or null for all services.
+	 * @return the list of initial <code>ServiceReference</code> objects.
+	 * @throws InvalidSyntaxException if the filter uses an invalid syntax.
+	 */
+	private ServiceReference[] getInitialReferences(boolean trackAllServices,
+			String trackClass, String filterString)
+			throws InvalidSyntaxException {
+		if (trackAllServices) {
+			return context.getAllServiceReferences(trackClass, filterString);
+		}
+		else {
+			return context.getServiceReferences(trackClass, filterString);
+		}
+	}
+
+	/**
+	 * Close this <code>ServiceTracker</code> object.
+	 * 
+	 * <p>
+	 * This method should be called when this <code>ServiceTracker</code>
+	 * object should end the tracking of services.
+	 */
+	public synchronized void close() {
+		if (tracked == null) {
+			return;
+		}
+		if (DEBUG) {
+			System.out.println("ServiceTracker.close: " + filter); //$NON-NLS-1$
+		}
+		tracked.close();
+		ServiceReference[] references = getServiceReferences();
+		Tracked outgoing = tracked;
+		tracked = null;
+		try {
+			context.removeServiceListener(outgoing);
+		}
+		catch (IllegalStateException e) {
+			/* In case the context was stopped. */
+		}
+		if (references != null) {
+			for (int i = 0; i < references.length; i++) {
+				outgoing.untrack(references[i]);
+			}
+		}
+		trackingCount = -1;
+		if (DEBUG) {
+			if ((cachedReference == null) && (cachedService == null)) {
+				System.out
+						.println("ServiceTracker.close[cached cleared]: " + filter); //$NON-NLS-1$
+			}
+		}
+	}
+
+	/**
+	 * Default implementation of the
+	 * <code>ServiceTrackerCustomizer.addingService</code> method.
+	 * 
+	 * <p>
+	 * This method is only called when this <code>ServiceTracker</code> object
+	 * has been constructed with a <code>null ServiceTrackerCustomizer</code>
+	 * argument.
+	 * 
+	 * The default implementation returns the result of calling
+	 * <code>getService</code>, on the <code>BundleContext</code> object
+	 * with which this <code>ServiceTracker</code> object was created, passing
+	 * the specified <code>ServiceReference</code> object.
+	 * <p>
+	 * This method can be overridden in a subclass to customize the service
+	 * object to be tracked for the service being added. In that case, take care
+	 * not to rely on the default implementation of removedService that will
+	 * unget the service.
+	 * 
+	 * @param reference Reference to service being added to this
+	 *        <code>ServiceTracker</code> object.
+	 * @return The service object to be tracked for the service added to this
+	 *         <code>ServiceTracker</code> object.
+	 * @see ServiceTrackerCustomizer
+	 */
+	public Object addingService(ServiceReference reference) {
+		return context.getService(reference);
+	}
+
+	/**
+	 * Default implementation of the
+	 * <code>ServiceTrackerCustomizer.modifiedService</code> method.
+	 * 
+	 * <p>
+	 * This method is only called when this <code>ServiceTracker</code> object
+	 * has been constructed with a <code>null ServiceTrackerCustomizer</code>
+	 * argument.
+	 * 
+	 * The default implementation does nothing.
+	 * 
+	 * @param reference Reference to modified service.
+	 * @param service The service object for the modified service.
+	 * @see ServiceTrackerCustomizer
+	 */
+	public void modifiedService(ServiceReference reference, Object service) {
+	}
+
+	/**
+	 * Default implementation of the
+	 * <code>ServiceTrackerCustomizer.removedService</code> method.
+	 * 
+	 * <p>
+	 * This method is only called when this <code>ServiceTracker</code> object
+	 * has been constructed with a <code>null ServiceTrackerCustomizer</code>
+	 * argument.
+	 * 
+	 * The default implementation calls <code>ungetService</code>, on the
+	 * <code>BundleContext</code> object with which this
+	 * <code>ServiceTracker</code> object was created, passing the specified
+	 * <code>ServiceReference</code> object.
+	 * <p>
+	 * This method can be overridden in a subclass. If the default
+	 * implementation of <code>addingService</code> method was used, this
+	 * method must unget the service.
+	 * 
+	 * @param reference Reference to removed service.
+	 * @param service The service object for the removed service.
+	 * @see ServiceTrackerCustomizer
+	 */
+	public void removedService(ServiceReference reference, Object service) {
+		context.ungetService(reference);
+	}
+
+	/**
+	 * Wait for at least one service to be tracked by this
+	 * <code>ServiceTracker</code> object.
+	 * <p>
+	 * It is strongly recommended that <code>waitForService</code> is not used
+	 * during the calling of the <code>BundleActivator</code> methods.
+	 * <code>BundleActivator</code> methods are expected to complete in a
+	 * short period of time.
+	 * 
+	 * @param timeout time interval in milliseconds to wait. If zero, the method
+	 *        will wait indefinately.
+	 * @return Returns the result of <code>getService()</code>.
+	 * @throws InterruptedException If another thread has interrupted the
+	 *         current thread.
+	 * @throws IllegalArgumentException If the value of timeout is negative.
+	 */
+	public Object waitForService(long timeout) throws InterruptedException {
+		if (timeout < 0) {
+			throw new IllegalArgumentException("timeout value is negative"); //$NON-NLS-1$
+		}
+		Object object = getService();
+		while (object == null) {
+			Tracked tracked = this.tracked; /*
+											 * use local var since we are not
+											 * synchronized
+											 */
+			if (tracked == null) { /* if ServiceTracker is not open */
+				return null;
+			}
+			synchronized (tracked) {
+				if (tracked.size() == 0) {
+					tracked.wait(timeout);
+				}
+			}
+			object = getService();
+			if (timeout > 0) {
+				return object;
+			}
+		}
+		return object;
+	}
+
+	/**
+	 * Return an array of <code>ServiceReference</code> objects for all
+	 * services being tracked by this <code>ServiceTracker</code> object.
+	 * 
+	 * @return Array of <code>ServiceReference</code> objects or
+	 *         <code>null</code> if no service are being tracked.
+	 */
+	public ServiceReference[] getServiceReferences() {
+		Tracked tracked = this.tracked; /*
+										 * use local var since we are not
+										 * synchronized
+										 */
+		if (tracked == null) { /* if ServiceTracker is not open */
+			return null;
+		}
+		synchronized (tracked) {
+			int length = tracked.size();
+			if (length == 0) {
+				return null;
+			}
+			ServiceReference[] references = new ServiceReference[length];
+			Enumeration keys = tracked.keys();
+			for (int i = 0; i < length; i++) {
+				references[i] = (ServiceReference) keys.nextElement();
+			}
+			return references;
+		}
+	}
+
+	/**
+	 * Returns a <code>ServiceReference</code> object for one of the services
+	 * being tracked by this <code>ServiceTracker</code> object.
+	 * 
+	 * <p>
+	 * If multiple services are being tracked, the service with the highest
+	 * ranking (as specified in its <code>service.ranking</code> property) is
+	 * returned.
+	 * 
+	 * <p>
+	 * If there is a tie in ranking, the service with the lowest service ID (as
+	 * specified in its <code>service.id</code> property); that is, the
+	 * service that was registered first is returned.
+	 * <p>
+	 * This is the same algorithm used by
+	 * <code>BundleContext.getServiceReference</code>.
+	 * 
+	 * @return <code>ServiceReference</code> object or <code>null</code> if
+	 *         no service is being tracked.
+	 * @since 1.1
+	 */
+	public ServiceReference getServiceReference() {
+		ServiceReference reference = cachedReference;
+		if (reference != null) {
+			if (DEBUG) {
+				System.out
+						.println("ServiceTracker.getServiceReference[cached]: " + filter); //$NON-NLS-1$
+			}
+			return reference;
+		}
+		if (DEBUG) {
+			System.out.println("ServiceTracker.getServiceReference: " + filter); //$NON-NLS-1$
+		}
+		ServiceReference[] references = getServiceReferences();
+		int length = (references == null) ? 0 : references.length;
+		if (length == 0) /* if no service is being tracked */
+		{
+			return null;
+		}
+		int index = 0;
+		if (length > 1) /* if more than one service, select highest ranking */
+		{
+			int rankings[] = new int[length];
+			int count = 0;
+			int maxRanking = Integer.MIN_VALUE;
+			for (int i = 0; i < length; i++) {
+				Object property = references[i]
+						.getProperty(Constants.SERVICE_RANKING);
+				int ranking = (property instanceof Integer) ? ((Integer) property)
+						.intValue()
+						: 0;
+				rankings[i] = ranking;
+				if (ranking > maxRanking) {
+					index = i;
+					maxRanking = ranking;
+					count = 1;
+				}
+				else {
+					if (ranking == maxRanking) {
+						count++;
+					}
+				}
+			}
+			if (count > 1) /* if still more than one service, select lowest id */
+			{
+				long minId = Long.MAX_VALUE;
+				for (int i = 0; i < length; i++) {
+					if (rankings[i] == maxRanking) {
+						long id = ((Long) (references[i]
+								.getProperty(Constants.SERVICE_ID)))
+								.longValue();
+						if (id < minId) {
+							index = i;
+							minId = id;
+						}
+					}
+				}
+			}
+		}
+		return cachedReference = references[index];
+	}
+
+	/**
+	 * Returns the service object for the specified
+	 * <code>ServiceReference</code> object if the referenced service is being
+	 * tracked by this <code>ServiceTracker</code> object.
+	 * 
+	 * @param reference Reference to the desired service.
+	 * @return Service object or <code>null</code> if the service referenced
+	 *         by the specified <code>ServiceReference</code> object is not
+	 *         being tracked.
+	 */
+	public Object getService(ServiceReference reference) {
+		Tracked tracked = this.tracked; /*
+										 * use local var since we are not
+										 * synchronized
+										 */
+		if (tracked == null) { /* if ServiceTracker is not open */
+			return null;
+		}
+		synchronized (tracked) {
+			return tracked.get(reference);
+		}
+	}
+
+	/**
+	 * Return an array of service objects for all services being tracked by this
+	 * <code>ServiceTracker</code> object.
+	 * 
+	 * @return Array of service objects or <code>null</code> if no service are
+	 *         being tracked.
+	 */
+	public Object[] getServices() {
+		Tracked tracked = this.tracked; /*
+										 * use local var since we are not
+										 * synchronized
+										 */
+		if (tracked == null) { /* if ServiceTracker is not open */
+			return null;
+		}
+		synchronized (tracked) {
+			ServiceReference[] references = getServiceReferences();
+			int length = (references == null) ? 0 : references.length;
+			if (length == 0) {
+				return null;
+			}
+			Object[] objects = new Object[length];
+			for (int i = 0; i < length; i++) {
+				objects[i] = getService(references[i]);
+			}
+			return objects;
+		}
+	}
+
+	/**
+	 * Returns a service object for one of the services being tracked by this
+	 * <code>ServiceTracker</code> object.
+	 * 
+	 * <p>
+	 * If any services are being tracked, this method returns the result of
+	 * calling <code>getService(getServiceReference())</code>.
+	 * 
+	 * @return Service object or <code>null</code> if no service is being
+	 *         tracked.
+	 */
+	public Object getService() {
+		Object service = cachedService;
+		if (service != null) {
+			if (DEBUG) {
+				System.out
+						.println("ServiceTracker.getService[cached]: " + filter); //$NON-NLS-1$
+			}
+			return service;
+		}
+		if (DEBUG) {
+			System.out.println("ServiceTracker.getService: " + filter); //$NON-NLS-1$
+		}
+		ServiceReference reference = getServiceReference();
+		if (reference == null) {
+			return null;
+		}
+		return cachedService = getService(reference);
+	}
+
+	/**
+	 * Remove a service from this <code>ServiceTracker</code> object.
+	 * 
+	 * The specified service will be removed from this
+	 * <code>ServiceTracker</code> object. If the specified service was being
+	 * tracked then the <code>ServiceTrackerCustomizer.removedService</code>
+	 * method will be called for that service.
+	 * 
+	 * @param reference Reference to the service to be removed.
+	 */
+	public void remove(ServiceReference reference) {
+		Tracked tracked = this.tracked; /*
+										 * use local var since we are not
+										 * synchronized
+										 */
+		if (tracked == null) { /* if ServiceTracker is not open */
+			return;
+		}
+		tracked.untrack(reference);
+	}
+
+	/**
+	 * Return the number of services being tracked by this
+	 * <code>ServiceTracker</code> object.
+	 * 
+	 * @return Number of services being tracked.
+	 */
+	public int size() {
+		Tracked tracked = this.tracked; /*
+										 * use local var since we are not
+										 * synchronized
+										 */
+		if (tracked == null) { /* if ServiceTracker is not open */
+			return 0;
+		}
+		return tracked.size();
+	}
+
+	/**
+	 * Returns the tracking count for this <code>ServiceTracker</code> object.
+	 * 
+	 * The tracking count is initialized to 0 when this
+	 * <code>ServiceTracker</code> object is opened. Every time a service is
+	 * added or removed from this <code>ServiceTracker</code> object the
+	 * tracking count is incremented.
+	 * 
+	 * <p>
+	 * The tracking count can be used to determine if this
+	 * <code>ServiceTracker</code> object has added or removed a service by
+	 * comparing a tracking count value previously collected with the current
+	 * tracking count value. If the value has not changed, then no service has
+	 * been added or removed from this <code>ServiceTracker</code> object
+	 * since the previous tracking count was collected.
+	 * 
+	 * @since 1.2
+	 * @return The tracking count for this <code>ServiceTracker</code> object
+	 *         or -1 if this <code>ServiceTracker</code> object is not open.
+	 */
+	public int getTrackingCount() {
+		return trackingCount;
+	}
+
+	/**
+	 * Called by the Tracked object whenever the set of tracked services is
+	 * modified. Increments the tracking count and clears the cache.
+	 */
+	/*
+	 * This method must not be synchronized since it is called by Tracked while
+	 * Tracked is synchronized. We don't want synchronization interactions
+	 * between the ServiceListener thread and the user thread.
+	 */
+	void modified() {
+		trackingCount++; /* increment modification count */
+		cachedReference = null; /* clear cached value */
+		cachedService = null; /* clear cached value */
+		if (DEBUG) {
+			System.out.println("ServiceTracker.modified: " + filter); //$NON-NLS-1$
+		}
+	}
+
+	/**
+	 * Finalize. This method no longer performs any function but it kept to
+	 * maintain binary compatibility with prior versions of this class.
+	 */
+	protected void finalize() throws Throwable {
+	}
+
+	/**
+	 * Inner class to track services. If a <code>ServiceTracker</code> object
+	 * is reused (closed then reopened), then a new Tracked object is used. This
+	 * class is a hashtable mapping <code>ServiceReference</code> object ->
+	 * customized Object. This class is the <code>ServiceListener</code>
+	 * object for the tracker. This class is used to synchronize access to the
+	 * tracked services. This is not a public class. It is only for use by the
+	 * implementation of the <code>ServiceTracker</code> class.
+	 * 
+	 */
+	class Tracked extends Hashtable implements ServiceListener {
+		static final long			serialVersionUID	= -7420065199791006079L;
+		/**
+		 * List of ServiceReferences in the process of being added. This is used
+		 * to deal with nesting of ServiceEvents. Since ServiceEvents are
+		 * synchronously delivered, ServiceEvents can be nested. For example,
+		 * when processing the adding of a service and the customizer causes the
+		 * service to be unregistered, notification to the nested call to
+		 * untrack that the service was unregistered can be made to the track
+		 * method.
+		 * 
+		 * Since the ArrayList implementation is not synchronized, all access to
+		 * this list must be protected by the same synchronized object for
+		 * thread safety.
+		 */
+		private ArrayList			adding;
+
+		/**
+		 * true if the tracked object is closed.
+		 * 
+		 * This field is volatile because it is set by one thread and read by
+		 * another.
+		 */
+		private volatile boolean	closed;
+
+		/**
+		 * Initial list of ServiceReferences for the tracker. This is used to
+		 * correctly process the initial services which could become
+		 * unregistered before they are tracked. This is necessary since the
+		 * initial set of tracked services are not "announced" by ServiceEvents
+		 * and therefore the ServiceEvent for unregistration could be delivered
+		 * before we track the service.
+		 * 
+		 * A service must not be in both the initial and adding lists at the
+		 * same time. A service must be moved from the initial list to the
+		 * adding list "atomically" before we begin tracking it.
+		 * 
+		 * Since the LinkedList implementation is not synchronized, all access
+		 * to this list must be protected by the same synchronized object for
+		 * thread safety.
+		 */
+		private LinkedList			initial;
+
+		/**
+		 * Tracked constructor.
+		 */
+		protected Tracked() {
+			super();
+			closed = false;
+			adding = new ArrayList(6);
+			initial = new LinkedList();
+		}
+
+		/**
+		 * Set initial list of services into tracker before ServiceEvents begin
+		 * to be received.
+		 * 
+		 * This method must be called from ServiceTracker.open while
+		 * synchronized on this object in the same synchronized block as the
+		 * addServiceListener call.
+		 * 
+		 * @param references The initial list of services to be tracked.
+		 */
+		protected void setInitialServices(ServiceReference[] references) {
+			if (references == null) {
+				return;
+			}
+			int size = references.length;
+			for (int i = 0; i < size; i++) {
+				if (DEBUG) {
+					System.out
+							.println("ServiceTracker.Tracked.setInitialServices: " + references[i]); //$NON-NLS-1$
+				}
+				initial.add(references[i]);
+			}
+		}
+
+		/**
+		 * Track the initial list of services. This is called after
+		 * ServiceEvents can begin to be received.
+		 * 
+		 * This method must be called from ServiceTracker.open while not
+		 * synchronized on this object after the addServiceListener call.
+		 * 
+		 */
+		protected void trackInitialServices() {
+			while (true) {
+				ServiceReference reference;
+				synchronized (this) {
+					if (initial.size() == 0) {
+						/*
+						 * if there are no more inital services
+						 */
+						return; /* we are done */
+					}
+					/*
+					 * move the first service from the initial list to the
+					 * adding list within this synchronized block.
+					 */
+					reference = (ServiceReference) initial.removeFirst();
+					if (this.get(reference) != null) {
+						/* if we are already tracking this service */
+						if (DEBUG) {
+							System.out
+									.println("ServiceTracker.Tracked.trackInitialServices[already tracked]: " + reference); //$NON-NLS-1$
+						}
+						continue; /* skip this service */
+					}
+					if (adding.contains(reference)) {
+						/*
+						 * if this service is already in the process of being
+						 * added.
+						 */
+						if (DEBUG) {
+							System.out
+									.println("ServiceTracker.Tracked.trackInitialServices[already adding]: " + reference); //$NON-NLS-1$
+						}
+						continue; /* skip this service */
+					}
+					adding.add(reference);
+				}
+				if (DEBUG) {
+					System.out
+							.println("ServiceTracker.Tracked.trackInitialServices: " + reference); //$NON-NLS-1$
+				}
+				trackAdding(reference); /*
+										 * Begin tracking it. We call
+										 * trackAdding since we have already put
+										 * the reference in the adding list.
+										 */
+			}
+		}
+
+		/**
+		 * Called by the owning <code>ServiceTracker</code> object when it is
+		 * closed.
+		 */
+		protected void close() {
+			closed = true;
+		}
+
+		/**
+		 * <code>ServiceListener</code> method for the
+		 * <code>ServiceTracker</code> class. This method must NOT be
+		 * synchronized to avoid deadlock potential.
+		 * 
+		 * @param event <code>ServiceEvent</code> object from the framework.
+		 */
+		public void serviceChanged(ServiceEvent event) {
+			/*
+			 * Check if we had a delayed call (which could happen when we
+			 * close).
+			 */
+			if (closed) {
+				return;
+			}
+			ServiceReference reference = event.getServiceReference();
+			if (DEBUG) {
+				System.out
+						.println("ServiceTracker.Tracked.serviceChanged[" + event.getType() + "]: " + reference); //$NON-NLS-1$ //$NON-NLS-2$
+			}
+
+			switch (event.getType()) {
+				case ServiceEvent.REGISTERED :
+				case ServiceEvent.MODIFIED :
+					if (listenerFilter != null) { // constructor supplied
+													// filter
+						track(reference);
+						/*
+						 * If the customizer throws an unchecked exception, it
+						 * is safe to let it propagate
+						 */
+					}
+					else { // user supplied filter
+						if (filter.match(reference)) {
+							track(reference);
+							/*
+							 * If the customizer throws an unchecked exception,
+							 * it is safe to let it propagate
+							 */
+						}
+						else {
+							untrack(reference);
+							/*
+							 * If the customizer throws an unchecked exception,
+							 * it is safe to let it propagate
+							 */
+						}
+					}
+					break;
+				case ServiceEvent.UNREGISTERING :
+					untrack(reference);
+					/*
+					 * If the customizer throws an unchecked exception, it is
+					 * safe to let it propagate
+					 */
+					break;
+			}
+		}
+
+		/**
+		 * Begin to track the referenced service.
+		 * 
+		 * @param reference Reference to a service to be tracked.
+		 */
+		protected void track(ServiceReference reference) {
+			Object object;
+			synchronized (this) {
+				object = this.get(reference);
+			}
+			if (object != null) /* we are already tracking the service */
+			{
+				if (DEBUG) {
+					System.out
+							.println("ServiceTracker.Tracked.track[modified]: " + reference); //$NON-NLS-1$
+				}
+				synchronized (this) {
+					modified(); /* increment modification count */
+				}
+				/* Call customizer outside of synchronized region */
+				customizer.modifiedService(reference, object);
+				/*
+				 * If the customizer throws an unchecked exception, it is safe
+				 * to let it propagate
+				 */
+				return;
+			}
+			synchronized (this) {
+				if (adding.contains(reference)) { /*
+													 * if this service is
+													 * already in the process of
+													 * being added.
+													 */
+					if (DEBUG) {
+						System.out
+								.println("ServiceTracker.Tracked.track[already adding]: " + reference); //$NON-NLS-1$
+					}
+					return;
+				}
+				adding.add(reference); /* mark this service is being added */
+			}
+
+			trackAdding(reference); /*
+									 * call trackAdding now that we have put the
+									 * reference in the adding list
+									 */
+		}
+
+		/**
+		 * Common logic to add a service to the tracker used by track and
+		 * trackInitialServices. The specified reference must have been placed
+		 * in the adding list before calling this method.
+		 * 
+		 * @param reference Reference to a service to be tracked.
+		 */
+		private void trackAdding(ServiceReference reference) {
+			if (DEBUG) {
+				System.out
+						.println("ServiceTracker.Tracked.trackAdding: " + reference); //$NON-NLS-1$
+			}
+			Object object = null;
+			boolean becameUntracked = false;
+			/* Call customizer outside of synchronized region */
+			try {
+				object = customizer.addingService(reference);
+				/*
+				 * If the customizer throws an unchecked exception, it will
+				 * propagate after the finally
+				 */
+			}
+			finally {
+				synchronized (this) {
+					if (adding.remove(reference)) { /*
+													 * if the service was not
+													 * untracked during the
+													 * customizer callback
+													 */
+						if (object != null) {
+							this.put(reference, object);
+							modified(); /* increment modification count */
+							notifyAll(); /*
+											 * notify any waiters in
+											 * waitForService
+											 */
+						}
+					}
+					else {
+						becameUntracked = true;
+					}
+				}
+			}
+			/*
+			 * The service became untracked during the customizer callback.
+			 */
+			if (becameUntracked) {
+				if (DEBUG) {
+					System.out
+							.println("ServiceTracker.Tracked.trackAdding[removed]: " + reference); //$NON-NLS-1$
+				}
+				/* Call customizer outside of synchronized region */
+				customizer.removedService(reference, object);
+				/*
+				 * If the customizer throws an unchecked exception, it is safe
+				 * to let it propagate
+				 */
+			}
+		}
+
+		/**
+		 * Discontinue tracking the referenced service.
+		 * 
+		 * @param reference Reference to the tracked service.
+		 */
+		protected void untrack(ServiceReference reference) {
+			Object object;
+			synchronized (this) {
+				if (initial.remove(reference)) { /*
+													 * if this service is
+													 * already in the list of
+													 * initial references to
+													 * process
+													 */
+					if (DEBUG) {
+						System.out
+								.println("ServiceTracker.Tracked.untrack[removed from initial]: " + reference); //$NON-NLS-1$
+					}
+					return; /*
+							 * we have removed it from the list and it will not
+							 * be processed
+							 */
+				}
+
+				if (adding.remove(reference)) { /*
+												 * if the service is in the
+												 * process of being added
+												 */
+					if (DEBUG) {
+						System.out
+								.println("ServiceTracker.Tracked.untrack[being added]: " + reference); //$NON-NLS-1$
+					}
+					return; /*
+							 * in case the service is untracked while in the
+							 * process of adding
+							 */
+				}
+				object = this.remove(reference); /*
+													 * must remove from tracker
+													 * before calling customizer
+													 * callback
+													 */
+				if (object == null) { /* are we actually tracking the service */
+					return;
+				}
+				modified(); /* increment modification count */
+			}
+			if (DEBUG) {
+				System.out
+						.println("ServiceTracker.Tracked.untrack[removed]: " + reference); //$NON-NLS-1$
+			}
+			/* Call customizer outside of synchronized region */
+			customizer.removedService(reference, object);
+			/*
+			 * If the customizer throws an unchecked exception, it is safe to
+			 * let it propagate
+			 */
+		}
+	}
+
+	/**
+	 * Subclass of Tracked which implements the AllServiceListener interface.
+	 * This class is used by the ServiceTracker if open is called with true.
+	 * 
+	 * @since 1.3
+	 */
+	class AllTracked extends Tracked implements AllServiceListener {
+		static final long	serialVersionUID	= 4050764875305137716L;
+
+		/**
+		 * AllTracked constructor.
+		 */
+		protected AllTracked() {
+			super();
+		}
+	}
+}

Added: felix/trunk/deploymentadmin/src/main/java/org/osgi/util/tracker/ServiceTrackerCustomizer.java
URL: http://svn.apache.org/viewvc/felix/trunk/deploymentadmin/src/main/java/org/osgi/util/tracker/ServiceTrackerCustomizer.java?rev=616813&view=auto
==============================================================================
--- felix/trunk/deploymentadmin/src/main/java/org/osgi/util/tracker/ServiceTrackerCustomizer.java (added)
+++ felix/trunk/deploymentadmin/src/main/java/org/osgi/util/tracker/ServiceTrackerCustomizer.java Wed Jan 30 08:46:24 2008
@@ -0,0 +1,92 @@
+/*
+ * $Header: /cvshome/build/org.osgi.util.tracker/src/org/osgi/util/tracker/ServiceTrackerCustomizer.java,v 1.10 2006/06/16 16:31:13 hargrave Exp $
+ * 
+ * Copyright (c) OSGi Alliance (2000, 2006). All Rights Reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.osgi.util.tracker;
+
+import org.osgi.framework.ServiceReference;
+
+/**
+ * The <code>ServiceTrackerCustomizer</code> interface allows a
+ * <code>ServiceTracker</code> object to customize the service objects that are
+ * tracked. The <code>ServiceTrackerCustomizer</code> object is called when a
+ * service is being added to the <code>ServiceTracker</code> object. The
+ * <code>ServiceTrackerCustomizer</code> can then return an object for the tracked
+ * service. The <code>ServiceTrackerCustomizer</code> object is also called when a
+ * tracked service is modified or has been removed from the
+ * <code>ServiceTracker</code> object.
+ * 
+ * <p>
+ * The methods in this interface may be called as the result of a
+ * <code>ServiceEvent</code> being received by a <code>ServiceTracker</code> object.
+ * Since <code>ServiceEvent</code> s are synchronously delivered by the Framework,
+ * it is highly recommended that implementations of these methods do not
+ * register (<code>BundleContext.registerService</code>), modify (
+ * <code>ServiceRegistration.setProperties</code>) or unregister (
+ * <code>ServiceRegistration.unregister</code>) a service while being
+ * synchronized on any object.
+ * 
+ * @version $Revision: 1.10 $
+ */
+public interface ServiceTrackerCustomizer {
+	/**
+	 * A service is being added to the <code>ServiceTracker</code> object.
+	 * 
+	 * <p>
+	 * This method is called before a service which matched the search
+	 * parameters of the <code>ServiceTracker</code> object is added to it. This
+	 * method should return the service object to be tracked for this
+	 * <code>ServiceReference</code> object. The returned service object is stored
+	 * in the <code>ServiceTracker</code> object and is available from the
+	 * <code>getService</code> and <code>getServices</code> methods.
+	 * 
+	 * @param reference Reference to service being added to the
+	 *        <code>ServiceTracker</code> object.
+	 * @return The service object to be tracked for the
+	 *         <code>ServiceReference</code> object or <code>null</code> if the
+	 *         <code>ServiceReference</code> object should not be tracked.
+	 */
+	public Object addingService(ServiceReference reference);
+
+	/**
+	 * A service tracked by the <code>ServiceTracker</code> object has been
+	 * modified.
+	 * 
+	 * <p>
+	 * This method is called when a service being tracked by the
+	 * <code>ServiceTracker</code> object has had it properties modified.
+	 * 
+	 * @param reference Reference to service that has been modified.
+	 * @param service The service object for the modified service.
+	 */
+	public void modifiedService(ServiceReference reference,
+			Object service);
+
+	/**
+	 * A service tracked by the <code>ServiceTracker</code> object has been
+	 * removed.
+	 * 
+	 * <p>
+	 * This method is called after a service is no longer being tracked by the
+	 * <code>ServiceTracker</code> object.
+	 * 
+	 * @param reference Reference to service that has been removed.
+	 * @param service The service object for the removed service.
+	 */
+	public void removedService(ServiceReference reference,
+			Object service);
+}

Added: felix/trunk/deploymentadmin/src/main/java/org/osgi/util/tracker/package.html
URL: http://svn.apache.org/viewvc/felix/trunk/deploymentadmin/src/main/java/org/osgi/util/tracker/package.html?rev=616813&view=auto
==============================================================================
--- felix/trunk/deploymentadmin/src/main/java/org/osgi/util/tracker/package.html (added)
+++ felix/trunk/deploymentadmin/src/main/java/org/osgi/util/tracker/package.html Wed Jan 30 08:46:24 2008
@@ -0,0 +1,10 @@
+<!-- $Header: /cvshome/build/org.osgi.util.tracker/src/org/osgi/util/tracker/package.html,v 1.4 2006/07/12 21:07:10 hargrave Exp $ -->
+<BODY>
+<p>Service Tracker Package Version 1.3.
+<p>Bundles wishing to use this package must list the package
+in the Import-Package header of the bundle's manifest.
+For example:
+<pre>
+Import-Package: org.osgi.util.tracker; version=1.3
+</pre>
+</BODY>

Added: felix/trunk/deploymentadmin/src/main/java/org/osgi/util/tracker/packageinfo
URL: http://svn.apache.org/viewvc/felix/trunk/deploymentadmin/src/main/java/org/osgi/util/tracker/packageinfo?rev=616813&view=auto
==============================================================================
--- felix/trunk/deploymentadmin/src/main/java/org/osgi/util/tracker/packageinfo (added)
+++ felix/trunk/deploymentadmin/src/main/java/org/osgi/util/tracker/packageinfo Wed Jan 30 08:46:24 2008
@@ -0,0 +1 @@
+version 1.3.2

Added: felix/trunk/deploymentadmin/src/main/java/org/osgi/util/xml/XMLParserActivator.java
URL: http://svn.apache.org/viewvc/felix/trunk/deploymentadmin/src/main/java/org/osgi/util/xml/XMLParserActivator.java?rev=616813&view=auto
==============================================================================
--- felix/trunk/deploymentadmin/src/main/java/org/osgi/util/xml/XMLParserActivator.java (added)
+++ felix/trunk/deploymentadmin/src/main/java/org/osgi/util/xml/XMLParserActivator.java Wed Jan 30 08:46:24 2008
@@ -0,0 +1,530 @@
+/*
+ * $Header: /cvshome/build/org.osgi.util.xml/src/org/osgi/util/xml/XMLParserActivator.java,v 1.10 2006/06/21 17:41:20 hargrave Exp $
+ * 
+ * Copyright (c) OSGi Alliance (2002, 2006). All Rights Reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.osgi.util.xml;
+
+import java.io.*;
+import java.net.URL;
+import java.util.*;
+
+import javax.xml.parsers.*;
+
+import org.osgi.framework.*;
+
+/**
+ * A BundleActivator class that allows any JAXP compliant XML Parser to register
+ * itself as an OSGi parser service.
+ * 
+ * Multiple JAXP compliant parsers can concurrently register by using this
+ * BundleActivator class. Bundles who wish to use an XML parser can then use the
+ * framework's service registry to locate available XML Parsers with the desired
+ * characteristics such as validating and namespace-aware.
+ * 
+ * <p>
+ * The services that this bundle activator enables a bundle to provide are:
+ * <ul>
+ * <li><code>javax.xml.parsers.SAXParserFactory</code>({@link #SAXFACTORYNAME})
+ * <li><code>javax.xml.parsers.DocumentBuilderFactory</code>(
+ * {@link #DOMFACTORYNAME})
+ * </ul>
+ * 
+ * <p>
+ * The algorithm to find the implementations of the abstract parsers is derived
+ * from the JAR file specifications, specifically the Services API.
+ * <p>
+ * An XMLParserActivator assumes that it can find the class file names of the
+ * factory classes in the following files:
+ * <ul>
+ * <li><code>/META-INF/services/javax.xml.parsers.SAXParserFactory</code> is
+ * a file contained in a jar available to the runtime which contains the
+ * implementation class name(s) of the SAXParserFactory.
+ * <li><code>/META-INF/services/javax.xml.parsers.DocumentBuilderFactory</code>
+ * is a file contained in a jar available to the runtime which contains the
+ * implementation class name(s) of the <code>DocumentBuilderFactory</code>
+ * </ul>
+ * <p>
+ * If either of the files does not exist, <code>XMLParserActivator</code>
+ * assumes that the parser does not support that parser type.
+ * 
+ * <p>
+ * <code>XMLParserActivator</code> attempts to instantiate both the
+ * <code>SAXParserFactory</code> and the <code>DocumentBuilderFactory</code>.
+ * It registers each factory with the framework along with service properties:
+ * <ul>
+ * <li>{@link #PARSER_VALIDATING}- indicates if this factory supports
+ * validating parsers. It's value is a <code>Boolean</code>.
+ * <li>{@link #PARSER_NAMESPACEAWARE}- indicates if this factory supports
+ * namespace aware parsers It's value is a <code>Boolean</code>.
+ * </ul>
+ * <p>
+ * Individual parser implementations may have additional features, properties,
+ * or attributes which could be used to select a parser with a filter. These can
+ * be added by extending this class and overriding the
+ * <code>setSAXProperties</code> and <code>setDOMProperties</code> methods.
+ */
+public class XMLParserActivator implements BundleActivator, ServiceFactory {
+	/** Context of this bundle */
+	private BundleContext		context;
+	/**
+	 * Filename containing the SAX Parser Factory Class name. Also used as the
+	 * basis for the <code>SERVICE_PID<code> registration property.
+	 */
+	public static final String	SAXFACTORYNAME			= "javax.xml.parsers.SAXParserFactory";
+	/**
+	 * Filename containing the DOM Parser Factory Class name. Also used as the
+	 * basis for the <code>SERVICE_PID</code> registration property.
+	 */
+	public static final String	DOMFACTORYNAME			= "javax.xml.parsers.DocumentBuilderFactory";
+	/** Path to the factory class name files */
+	private static final String	PARSERCLASSFILEPATH		= "/META-INF/services/";
+	/** Fully qualified path name of SAX Parser Factory Class Name file */
+	public static final String	SAXCLASSFILE			= PARSERCLASSFILEPATH
+																+ SAXFACTORYNAME;
+	/** Fully qualified path name of DOM Parser Factory Class Name file */
+	public static final String	DOMCLASSFILE			= PARSERCLASSFILEPATH
+																+ DOMFACTORYNAME;
+	/** SAX Factory Service Description */
+	private static final String	SAXFACTORYDESCRIPTION	= "A JAXP Compliant SAX Parser";
+	/** DOM Factory Service Description */
+	private static final String	DOMFACTORYDESCRIPTION	= "A JAXP Compliant DOM Parser";
+	/**
+	 * Service property specifying if factory is configured to support
+	 * validating parsers. The value is of type <code>Boolean</code>.
+	 */
+	public static final String	PARSER_VALIDATING		= "parser.validating";
+	/**
+	 * Service property specifying if factory is configured to support namespace
+	 * aware parsers. The value is of type <code>Boolean</code>.
+	 */
+	public static final String	PARSER_NAMESPACEAWARE	= "parser.namespaceAware";
+	/**
+	 * Key for parser factory name property - this must be saved in the parsers
+	 * properties hashtable so that the parser factory can be instantiated from
+	 * a ServiceReference
+	 */
+	private static final String	FACTORYNAMEKEY			= "parser.factoryname";
+
+	/**
+	 * Called when this bundle is started so the Framework can perform the
+	 * bundle-specific activities necessary to start this bundle. This method
+	 * can be used to register services or to allocate any resources that this
+	 * bundle needs.
+	 * 
+	 * <p>
+	 * This method must complete and return to its caller in a timely manner.
+	 * 
+	 * <p>
+	 * This method attempts to register a SAX and DOM parser with the
+	 * Framework's service registry.
+	 * 
+	 * @param context The execution context of the bundle being started.
+	 * @throws java.lang.Exception If this method throws an exception, this
+	 *         bundle is marked as stopped and the Framework will remove this
+	 *         bundle's listeners, unregister all services registered by this
+	 *         bundle, and release all services used by this bundle.
+	 * @see Bundle#start
+	 */
+	public void start(BundleContext context) throws Exception {
+		this.context = context;
+		Bundle parserBundle = context.getBundle();
+		try {
+			// check for sax parsers
+			registerSAXParsers(getParserFactoryClassNames(parserBundle
+					.getResource(SAXCLASSFILE)));
+			// check for dom parsers
+			registerDOMParsers(getParserFactoryClassNames(parserBundle
+					.getResource(DOMCLASSFILE)));
+		}
+		catch (IOException ioe) {
+			// if there were any IO errors accessing the resource files
+			// containing the class names
+			ioe.printStackTrace();
+			throw new FactoryConfigurationError(ioe);
+		}
+	}
+
+	/**
+	 * <p>
+	 * This method has nothing to do as all active service registrations will
+	 * automatically get unregistered when the bundle stops.
+	 * 
+	 * @param context The execution context of the bundle being stopped.
+	 * @throws java.lang.Exception If this method throws an exception, the
+	 *         bundle is still marked as stopped, and the Framework will remove
+	 *         the bundle's listeners, unregister all services registered by the
+	 *         bundle, and release all services used by the bundle.
+	 * @see Bundle#stop
+	 */
+	public void stop(BundleContext context) throws Exception {
+	}
+
+	/**
+	 * Given the URL for a file, reads and returns the parser class names. There
+	 * may be multiple classes specified in this file, one per line. There may
+	 * also be comment lines in the file, which begin with "#".
+	 * 
+	 * @param parserUrl The URL of the service file containing the parser class
+	 *        names
+	 * @return A vector of strings containing the parser class names or null if
+	 *         parserUrl is null
+	 * @throws IOException if there is a problem reading the URL input stream
+	 */
+	private Vector getParserFactoryClassNames(URL parserUrl) throws IOException {
+		Vector v = new Vector(1);
+		if (parserUrl != null) {
+			String parserFactoryClassName = null;
+			InputStream is = parserUrl.openStream();
+			BufferedReader br = new BufferedReader(new InputStreamReader(is));
+			while (true) {
+				parserFactoryClassName = br.readLine();
+				if (parserFactoryClassName == null) {
+					break; // end of file reached
+				}
+				String pfcName = parserFactoryClassName.trim();
+				if (pfcName.length() == 0) {
+					continue; // blank line
+				}
+				int commentIdx = pfcName.indexOf("#");
+				if (commentIdx == 0) { // comment line
+					continue;
+				}
+				else
+					if (commentIdx < 0) { // no comment on this line
+						v.addElement(pfcName);
+					}
+					else {
+						v.addElement(pfcName.substring(0, commentIdx).trim());
+					}
+			}
+			return v;
+		}
+		else {
+			return null;
+		}
+	}
+
+	/**
+	 * Register SAX Parser Factory Services with the framework.
+	 * 
+	 * @param parserFactoryClassNames - a <code>Vector</code> of
+	 *        <code>String</code> objects containing the names of the parser
+	 *        Factory Classes
+	 * @throws FactoryConfigurationError if thrown from <code>getFactory</code>
+	 */
+	private void registerSAXParsers(Vector parserFactoryClassNames)
+			throws FactoryConfigurationError {
+		if (parserFactoryClassNames != null) {
+			Enumeration e = parserFactoryClassNames.elements();
+			int index = 0;
+			while (e.hasMoreElements()) {
+				String parserFactoryClassName = (String) e.nextElement();
+				// create a sax parser factory just to get it's default
+				// properties. It will never be used since
+				// this class will operate as a service factory and give each
+				// service requestor it's own SaxParserFactory
+				SAXParserFactory factory = (SAXParserFactory) getFactory(parserFactoryClassName);
+				Hashtable properties = new Hashtable(7);
+				// figure out the default properties of the parser
+				setDefaultSAXProperties(factory, properties, index);
+				// store the parser factory class name in the properties so that
+				// it can be retrieved when getService is called
+				// to return a parser factory
+				properties.put(FACTORYNAMEKEY, parserFactoryClassName);
+				// release the factory
+				factory = null;
+				// register the factory as a service
+				context.registerService(SAXFACTORYNAME, this, properties);
+				index++;
+			}
+		}
+	}
+
+	/**
+	 * <p>
+	 * Set the SAX Parser Service Properties. By default, the following
+	 * properties are set:
+	 * <ul>
+	 * <li><code>SERVICE_DESCRIPTION</code>
+	 * <li><code>SERVICE_PID</code>
+	 * <li><code>PARSER_VALIDATING</code>- instantiates a parser and queries
+	 * it to find out whether it is validating or not
+	 * <li><code>PARSER_NAMESPACEAWARE</code>- instantiates a parser and
+	 * queries it to find out whether it is namespace aware or not
+	 * <ul>
+	 * 
+	 * @param factory The <code>SAXParserFactory</code> object
+	 * @param props <code>Hashtable</code> of service properties.
+	 */
+	private void setDefaultSAXProperties(SAXParserFactory factory,
+			Hashtable props, int index) {
+		props.put(Constants.SERVICE_DESCRIPTION, SAXFACTORYDESCRIPTION);
+		props.put(Constants.SERVICE_PID, SAXFACTORYNAME + "."
+				+ context.getBundle().getBundleId() + "." + index);
+		setSAXProperties(factory, props);
+	}
+
+	/**
+	 * <p>
+	 * Set the customizable SAX Parser Service Properties.
+	 * 
+	 * <p>
+	 * This method attempts to instantiate a validating parser and a
+	 * namespaceaware parser to determine if the parser can support those
+	 * features. The appropriate properties are then set in the specified
+	 * properties object.
+	 * 
+	 * <p>
+	 * This method can be overridden to add additional SAX2 features and
+	 * properties. If you want to be able to filter searches of the OSGi service
+	 * registry, this method must put a key, value pair into the properties
+	 * object for each feature or property. For example,
+	 * 
+	 * properties.put("http://www.acme.com/features/foo", Boolean.TRUE);
+	 * 
+	 * @param factory - the SAXParserFactory object
+	 * @param properties - the properties object for the service
+	 */
+	public void setSAXProperties(SAXParserFactory factory, Hashtable properties) {
+		// check if this parser can be configured to validate
+		boolean validating = true;
+		factory.setValidating(true);
+		factory.setNamespaceAware(false);
+		try {
+			factory.newSAXParser();
+		}
+		catch (Exception pce_val) {
+			validating = false;
+		}
+		// check if this parser can be configured to be namespaceaware
+		boolean namespaceaware = true;
+		factory.setValidating(false);
+		factory.setNamespaceAware(true);
+		try {
+			factory.newSAXParser();
+		}
+		catch (Exception pce_nsa) {
+			namespaceaware = false;
+		}
+		// set the factory values
+		factory.setValidating(validating);
+		factory.setNamespaceAware(namespaceaware);
+		// set the OSGi service properties
+		properties.put(PARSER_NAMESPACEAWARE, new Boolean(namespaceaware));
+		properties.put(PARSER_VALIDATING, new Boolean(validating));
+	}
+
+	/**
+	 * Register DOM Parser Factory Services with the framework.
+	 * 
+	 * @param parserFactoryClassNames - a <code>Vector</code> of
+	 *        <code>String</code> objects containing the names of the parser
+	 *        Factory Classes
+	 * @throws FactoryConfigurationError if thrown from <code>getFactory</code>
+	 */
+	private void registerDOMParsers(Vector parserFactoryClassNames)
+			throws FactoryConfigurationError {
+		if (parserFactoryClassNames != null) {
+			Enumeration e = parserFactoryClassNames.elements();
+			int index = 0;
+			while (e.hasMoreElements()) {
+				String parserFactoryClassName = (String) e.nextElement();
+				// create a dom parser factory just to get it's default
+				// properties. It will never be used since
+				// this class will operate as a service factory and give each
+				// service requestor it's own DocumentBuilderFactory
+				DocumentBuilderFactory factory = (DocumentBuilderFactory) getFactory(parserFactoryClassName);
+				Hashtable properties = new Hashtable(7);
+				// figure out the default properties of the parser
+				setDefaultDOMProperties(factory, properties, index);
+				// store the parser factory class name in the properties so that
+				// it can be retrieved when getService is called
+				// to return a parser factory
+				properties.put(FACTORYNAMEKEY, parserFactoryClassName);
+				// release the factory
+				factory = null;
+				// register the factory as a service
+				context.registerService(DOMFACTORYNAME, this, properties);
+				index++;
+			}
+		}
+	}
+
+	/**
+	 * Set the DOM parser service properties.
+	 * 
+	 * By default, the following properties are set:
+	 * <ul>
+	 * <li><code>SERVICE_DESCRIPTION</code>
+	 * <li><code>SERVICE_PID</code>
+	 * <li><code>PARSER_VALIDATING</code>
+	 * <li><code>PARSER_NAMESPACEAWARE</code>
+	 * <ul>
+	 * 
+	 * @param factory The <code>DocumentBuilderFactory</code> object
+	 * @param props <code>Hashtable</code> of service properties.
+	 */
+	private void setDefaultDOMProperties(DocumentBuilderFactory factory,
+			Hashtable props, int index) {
+		props.put(Constants.SERVICE_DESCRIPTION, DOMFACTORYDESCRIPTION);
+		props.put(Constants.SERVICE_PID, DOMFACTORYNAME + "."
+				+ context.getBundle().getBundleId() + "." + index);
+		setDOMProperties(factory, props);
+	}
+
+	/**
+	 * <p>
+	 * Set the customizable DOM Parser Service Properties.
+	 * 
+	 * <p>
+	 * This method attempts to instantiate a validating parser and a
+	 * namespaceaware parser to determine if the parser can support those
+	 * features. The appropriate properties are then set in the specified props
+	 * object.
+	 * 
+	 * <p>
+	 * This method can be overridden to add additional DOM2 features and
+	 * properties. If you want to be able to filter searches of the OSGi service
+	 * registry, this method must put a key, value pair into the properties
+	 * object for each feature or property. For example,
+	 * 
+	 * properties.put("http://www.acme.com/features/foo", Boolean.TRUE);
+	 * 
+	 * @param factory - the DocumentBuilderFactory object
+	 * @param props - Hashtable of service properties.
+	 */
+	public void setDOMProperties(DocumentBuilderFactory factory, Hashtable props) {
+		// check if this parser can be configured to validate
+		boolean validating = true;
+		factory.setValidating(true);
+		factory.setNamespaceAware(false);
+		try {
+			factory.newDocumentBuilder();
+		}
+		catch (Exception pce_val) {
+			validating = false;
+		}
+		// check if this parser can be configured to be namespaceaware
+		boolean namespaceaware = true;
+		factory.setValidating(false);
+		factory.setNamespaceAware(true);
+		try {
+			factory.newDocumentBuilder();
+		}
+		catch (Exception pce_nsa) {
+			namespaceaware = false;
+		}
+		// set the factory values
+		factory.setValidating(validating);
+		factory.setNamespaceAware(namespaceaware);
+		// set the OSGi service properties
+		props.put(PARSER_VALIDATING, new Boolean(validating));
+		props.put(PARSER_NAMESPACEAWARE, new Boolean(namespaceaware));
+	}
+
+	/**
+	 * Given a parser factory class name, instantiate that class.
+	 * 
+	 * @param parserFactoryClassName A <code>String</code> object containing
+	 *        the name of the parser factory class
+	 * @return a parserFactoryClass Object
+	 * @pre parserFactoryClassName!=null
+	 */
+	private Object getFactory(String parserFactoryClassName)
+			throws FactoryConfigurationError {
+		Exception e = null;
+		try {
+			return Class.forName(parserFactoryClassName).newInstance();
+		}
+		catch (ClassNotFoundException cnfe) {
+			e = cnfe;
+		}
+		catch (InstantiationException ie) {
+			e = ie;
+		}
+		catch (IllegalAccessException iae) {
+			e = iae;
+		}
+		throw new FactoryConfigurationError(e);
+	}
+
+	/**
+	 * Creates a new XML Parser Factory object.
+	 * 
+	 * <p>
+	 * A unique XML Parser Factory object is returned for each call to this
+	 * method.
+	 * 
+	 * <p>
+	 * The returned XML Parser Factory object will be configured for validating
+	 * and namespace aware support as specified in the service properties of the
+	 * specified ServiceRegistration object.
+	 * 
+	 * This method can be overridden to configure additional features in the
+	 * returned XML Parser Factory object.
+	 * 
+	 * @param bundle The bundle using the service.
+	 * @param registration The <code>ServiceRegistration</code> object for the
+	 *        service.
+	 * @return A new, configured XML Parser Factory object or null if a
+	 *         configuration error was encountered
+	 */
+	public Object getService(Bundle bundle, ServiceRegistration registration) {
+		ServiceReference sref = registration.getReference();
+		String parserFactoryClassName = (String) sref
+				.getProperty(FACTORYNAMEKEY);
+		try {
+			// need to set factory properties
+			Object factory = getFactory(parserFactoryClassName);
+			if (factory instanceof SAXParserFactory) {
+				((SAXParserFactory) factory).setValidating(((Boolean) sref
+						.getProperty(PARSER_VALIDATING)).booleanValue());
+				((SAXParserFactory) factory).setNamespaceAware(((Boolean) sref
+						.getProperty(PARSER_NAMESPACEAWARE)).booleanValue());
+			}
+			else
+				if (factory instanceof DocumentBuilderFactory) {
+					((DocumentBuilderFactory) factory)
+							.setValidating(((Boolean) sref
+									.getProperty(PARSER_VALIDATING))
+									.booleanValue());
+					((DocumentBuilderFactory) factory)
+							.setNamespaceAware(((Boolean) sref
+									.getProperty(PARSER_NAMESPACEAWARE))
+									.booleanValue());
+				}
+			return factory;
+		}
+		catch (FactoryConfigurationError fce) {
+			fce.printStackTrace();
+			return null;
+		}
+	}
+
+	/**
+	 * Releases a XML Parser Factory object.
+	 * 
+	 * @param bundle The bundle releasing the service.
+	 * @param registration The <code>ServiceRegistration</code> object for the
+	 *        service.
+	 * @param service The XML Parser Factory object returned by a previous call
+	 *        to the <code>getService</code> method.
+	 */
+	public void ungetService(Bundle bundle, ServiceRegistration registration,
+			Object service) {
+	}
+}

Added: felix/trunk/deploymentadmin/src/main/java/org/osgi/util/xml/package.html
URL: http://svn.apache.org/viewvc/felix/trunk/deploymentadmin/src/main/java/org/osgi/util/xml/package.html?rev=616813&view=auto
==============================================================================
--- felix/trunk/deploymentadmin/src/main/java/org/osgi/util/xml/package.html (added)
+++ felix/trunk/deploymentadmin/src/main/java/org/osgi/util/xml/package.html Wed Jan 30 08:46:24 2008
@@ -0,0 +1,10 @@
+<!-- $Header: /cvshome/build/org.osgi.util.xml/src/org/osgi/util/xml/package.html,v 1.2 2006/07/12 21:06:59 hargrave Exp $ -->
+<BODY>
+<p>XML Parser Package Version 1.0.
+<p>Bundles wishing to use this package must list the package
+in the Import-Package header of the bundle's manifest.
+For example:
+<pre>
+Import-Package: org.osgi.util.xml; version=1.0
+</pre>
+</BODY>

Added: felix/trunk/deploymentadmin/src/main/java/org/osgi/util/xml/packageinfo
URL: http://svn.apache.org/viewvc/felix/trunk/deploymentadmin/src/main/java/org/osgi/util/xml/packageinfo?rev=616813&view=auto
==============================================================================
--- felix/trunk/deploymentadmin/src/main/java/org/osgi/util/xml/packageinfo (added)
+++ felix/trunk/deploymentadmin/src/main/java/org/osgi/util/xml/packageinfo Wed Jan 30 08:46:24 2008
@@ -0,0 +1 @@
+version 1.0
\ No newline at end of file



Mime
View raw message