ResourceChangeListenerList.java

/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.core.internal.events;

import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.runtime.Assert;

/**
 * This class is used to maintain a list of listeners. It is a fairly lightweight object, occupying
 * minimal space when no listeners are registered.
 * <p>
 * Note that the <code>add</code> method checks for and eliminates duplicates based on identity (not
 * equality). Likewise, the <code>remove</code> method compares based on identity.
 * </p>
 * <p>
 * This implementation is thread safe. The listener list is copied every time it is modified, so
 * readers do not need to copy or synchronize. This optimizes for frequent reads and infrequent
 * writes, and assumes that readers can be trusted not to modify the returned array.
 */
public class ResourceChangeListenerList {

	static class ListenerEntry {
		int eventMask;

		IResourceChangeListener listener;

		ListenerEntry(IResourceChangeListener listener, int eventMask) {
			this.listener= listener;
			this.eventMask= eventMask;
		}
	}

	/**
	 * The empty array singleton instance.
	 */
	private static final ListenerEntry[] EMPTY_ARRAY= new ListenerEntry[0];

	private int count1= 0;

	private int count2= 0;

	private int count4= 0;

	private int count8= 0;

	private int count16= 0;

	private int count32= 0;

	/**
	 * The list of listeners. Maintains invariant: listeners != null.
	 */
	private volatile ListenerEntry[] listeners= EMPTY_ARRAY;

	/**
	 * Adds the given listener to this list. Has no effect if an identical listener is already
	 * registered.
	 * 
	 * @param listener the listener
	 * @param mask event types
	 */
	public synchronized void add(IResourceChangeListener listener, int mask) {
		Assert.isNotNull(listener);
		if (mask == 0) {
			remove(listener);
			return;
		}
		ResourceChangeListenerList.ListenerEntry entry= new ResourceChangeListenerList.ListenerEntry(listener, mask);
		final int oldSize= listeners.length;
		// check for duplicates using identity
		for (int i= 0; i < oldSize; ++i) {
			if (listeners[i].listener == listener) {
				removing(listeners[i].eventMask);
				adding(mask);
				listeners[i]= entry;
				return;
			}
		}
		adding(mask);
		// Thread safety: copy on write to protect concurrent readers.
		ListenerEntry[] newListeners= new ListenerEntry[oldSize + 1];
		System.arraycopy(listeners, 0, newListeners, 0, oldSize);
		newListeners[oldSize]= entry;
		//atomic assignment
		this.listeners= newListeners;
	}

	private void adding(int mask) {
		if ((mask & 1) != 0)
			count1++;
		if ((mask & 2) != 0)
			count2++;
		if ((mask & 4) != 0)
			count4++;
		if ((mask & 8) != 0)
			count8++;
		if ((mask & 16) != 0)
			count16++;
		if ((mask & 32) != 0)
			count32++;
	}

	/**
	 * Returns an array containing all the registered listeners. The resulting array is unaffected
	 * by subsequent adds or removes. If there are no listeners registered, the result is an empty
	 * array singleton instance (no garbage is created). Use this method when notifying listeners,
	 * so that any modifications to the listener list during the notification will have no effect on
	 * the notification itself.
	 * <p>
	 * Note: Clients must not modify the returned list
	 * 
	 * @return the list of registered listeners that must not be modified
	 */
	public ListenerEntry[] getListeners() {
		return listeners;
	}

	public boolean hasListenerFor(int event) {
		if (event == 1)
			return count1 > 0;
		if (event == 2)
			return count2 > 0;
		if (event == 4)
			return count4 > 0;
		if (event == 8)
			return count8 > 0;
		if (event == 16)
			return count16 > 0;
		if (event == 32)
			return count32 > 0;
		return false;
	}

	/**
	 * Removes the given listener from this list. Has no effect if an identical listener was not
	 * already registered.
	 * 
	 * @param listener the listener to remove
	 */
	public synchronized void remove(IResourceChangeListener listener) {
		Assert.isNotNull(listener);
		final int oldSize= listeners.length;
		for (int i= 0; i < oldSize; ++i) {
			if (listeners[i].listener == listener) {
				removing(listeners[i].eventMask);
				if (oldSize == 1) {
					listeners= EMPTY_ARRAY;
				} else {
					// Thread safety: create new array to avoid affecting concurrent readers
					ListenerEntry[] newListeners= new ListenerEntry[oldSize - 1];
					System.arraycopy(listeners, 0, newListeners, 0, i);
					System.arraycopy(listeners, i + 1, newListeners, i, oldSize - i - 1);
					//atomic assignment to field
					this.listeners= newListeners;
				}
				return;
			}
		}
	}

	private void removing(int mask) {
		if ((mask & 1) != 0)
			count1--;
		if ((mask & 2) != 0)
			count2--;
		if ((mask & 4) != 0)
			count4--;
		if ((mask & 8) != 0)
			count8--;
		if ((mask & 16) != 0)
			count16--;
		if ((mask & 32) != 0)
			count32--;
	}
}