/*******************************************************************************
* Copyright (c) 2006 Sybase, Inc. 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:
* Sybase, Inc. - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.pagedesigner.jsp.core;
/**
* Local version of org.eclipse.jface.util.ListenerList (modified)
* @author mengbo
* @version 1.5
*/
public class ListenerList {
/**
* The current number of listeners. Maintains invariant: 0 <= fSize <=
* listeners.length.
*/
private int _size;
/**
* The list of listeners. Initially <code>null</code> but initialized to
* an array of size capacity the first time a listener is added. Maintains
* invariant: listeners != null if and only if fSize != 0
*/
private Object[] _listeners = null;
/**
* The empty array singleton instance, returned by getListeners() when size ==
* 0.
*/
private static final Object[] EmptyArray = new Object[0];
/**
* Creates a listener list with the given initial capacity.
*
* @param capacity
* the number of listeners which this list can initially accept
* without growing its internal representation; must be at least
* 1
*/
public ListenerList(int capacity) {
if (capacity < 1) {
throw new IllegalArgumentException();
}
_listeners = new Object[capacity];
_size = 0;
}
/**
* Adds a listener to the list. Has no effect if an identical listener is
* already registered.
*
* @param listener
* a listener
*/
public synchronized void add(Object listener) {
if (listener == null) {
throw new IllegalArgumentException();
}
// check for duplicates using identity
for (int i = 0; i < _size; ++i) {
if (_listeners[i] == listener) {
return;
}
}
// grow array if necessary
if (_size == _listeners.length) {
Object[] temp = new Object[(_size * 2) + 1];
System.arraycopy(_listeners, 0, temp, 0, _size);
_listeners = temp;
}
_listeners[_size++] = listener;
}
/**
* 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.
* @return the array of registered listeners
*/
public synchronized Object[] getListeners() {
if (_size == 0) {
return EmptyArray;
}
Object[] result = new Object[_size];
System.arraycopy(_listeners, 0, result, 0, _size);
return result;
}
/**
* Removes a listener from the list. Has no effect if an identical listener
* was not already registered.
*
* @param listener
* a listener
*/
public synchronized void remove(Object listener) {
if (listener == null) {
throw new IllegalArgumentException();
}
for (int i = 0; i < _size; ++i) {
if (_listeners[i] == listener) {
if (--_size == 0) {
_listeners = new Object[1];
} else {
if (i < _size) {
_listeners[i] = _listeners[_size];
}
_listeners[_size] = null;
}
return;
}
}
}
/**
* Removes all the listeners from the list.
*/
public void removeAll() {
_listeners = new Object[0];
_size = 0;
}
/**
* Returns the number of registered listeners
*
* @return the number of registered listeners
*/
public int size() {
return _size;
}
}