DefaultListModel.java

/*
 * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation. Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

packagejavax.swing;

importjava.util.Vector;
importjava.util.Collection;
importjava.util.Enumeration;


/**
 * This class loosely implements the {@code java.util.Vector}
 * API, in that it implements the 1.1.x version of
 * {@code java.util.Vector}, has no collection class support,
 * and notifies the {@code ListDataListener}s when changes occur.
 * Presently it delegates to a {@code Vector},
 * in a future release it will be a real Collection implementation.
 * <p>
 * <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with
 * future Swing releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running
 * the same version of Swing. As of 1.4, support for long term storage
 * of all JavaBeans
 * has been added to the {@code java.beans} package.
 * Please see {@link java.beans.XMLEncoder}.
 *
 * @param <E> the type of the elements of this model
 *
 * @author Hans Muller
 * @since 1.2
 */
@SuppressWarnings("serial") // Same-version serialization only
publicclassDefaultListModel<E> extendsAbstractListModel<E>
{
privateVector<E> delegate = newVector<E>();

/**
 * Constructs a {@code DefaultListModel}.
 */
publicDefaultListModel() {}

/**
 * Returns the number of components in this list.
 * <p>
 * This method is identical to {@code size}, which implements the
 * {@code List} interface defined in the 1.2 Collections framework.
 * This method exists in conjunction with {@code setSize} so that
 * {@code size} is identifiable as a JavaBean property.
 *
 * @return the number of components in this list
 * @see #size()
 */
publicintgetSize() {
returndelegate.size();
 }

/**
 * Returns the component at the specified index.
 * <blockquote>
 * <b>Note:</b> Although this method is not deprecated, the preferred
 * method to use is {@code get(int)}, which implements the {@code List}
 * interface defined in the 1.2 Collections framework.
 * </blockquote>
 * @param index an index into this list
 * @return the component at the specified index
 * @throws ArrayIndexOutOfBoundsException if the {@code index}
 * is negative or greater than the current size of this
 * list
 * @see #get(int)
 */
publicEgetElementAt(intindex) {
returndelegate.elementAt(index);
 }

/**
 * Copies the components of this list into the specified array.
 * The array must be big enough to hold all the objects in this list,
 * else an {@code IndexOutOfBoundsException} is thrown.
 *
 * @param anArray the array into which the components get copied
 * @see Vector#copyInto(Object[])
 */
publicvoidcopyInto(Object[] anArray) {
delegate.copyInto(anArray);
 }

/**
 * Trims the capacity of this list to be the list's current size.
 *
 * @see Vector#trimToSize()
 */
publicvoidtrimToSize() {
delegate.trimToSize();
 }

/**
 * Increases the capacity of this list, if necessary, to ensure
 * that it can hold at least the number of components specified by
 * the minimum capacity argument.
 *
 * @param minCapacity the desired minimum capacity
 * @see Vector#ensureCapacity(int)
 */
publicvoidensureCapacity(intminCapacity) {
delegate.ensureCapacity(minCapacity);
 }

/**
 * Sets the size of this list.
 *
 * @param newSize the new size of this list
 * @see Vector#setSize(int)
 */
publicvoidsetSize(intnewSize) {
intoldSize = delegate.size();
delegate.setSize(newSize);
if (oldSize > newSize) {
fireIntervalRemoved(this, newSize, oldSize-1);
 }
elseif (oldSize < newSize) {
fireIntervalAdded(this, oldSize, newSize-1);
 }
 }

/**
 * Returns the current capacity of this list.
 *
 * @return the current capacity
 * @see Vector#capacity()
 */
publicintcapacity() {
returndelegate.capacity();
 }

/**
 * Returns the number of components in this list.
 *
 * @return the number of components in this list
 * @see Vector#size()
 */
publicintsize() {
returndelegate.size();
 }

/**
 * Tests whether this list has any components.
 *
 * @return {@code true} if and only if this list has
 * no components, that is, its size is zero;
 * {@code false} otherwise
 * @see Vector#isEmpty()
 */
publicbooleanisEmpty() {
returndelegate.isEmpty();
 }

/**
 * Returns an enumeration of the components of this list.
 *
 * @return an enumeration of the components of this list
 * @see Vector#elements()
 */
publicEnumeration<E> elements() {
returndelegate.elements();
 }

/**
 * Tests whether the specified object is a component in this list.
 *
 * @param elem an object
 * @return {@code true} if the specified object
 * is the same as a component in this list
 * @see Vector#contains(Object)
 */
publicbooleancontains(Objectelem) {
returndelegate.contains(elem);
 }

/**
 * Searches for the first occurrence of {@code elem}.
 *
 * @param elem an object
 * @return the index of the first occurrence of the argument in this
 * list; returns {@code -1} if the object is not found
 * @see Vector#indexOf(Object)
 */
publicintindexOf(Objectelem) {
returndelegate.indexOf(elem);
 }

/**
 * Searches for the first occurrence of {@code elem}, beginning
 * the search at {@code index}.
 *
 * @param elem the desired component
 * @param index the index from which to begin searching
 * @return the index where the first occurrence of {@code elem}
 * is found after {@code index}; returns {@code -1}
 * if the {@code elem} is not found in the list
 * @see Vector#indexOf(Object,int)
 */
publicintindexOf(Objectelem, intindex) {
returndelegate.indexOf(elem, index);
 }

/**
 * Returns the index of the last occurrence of {@code elem}.
 *
 * @param elem the desired component
 * @return the index of the last occurrence of {@code elem}
 * in the list; returns {@code elem} if the object is not found
 * @see Vector#lastIndexOf(Object)
 */
publicintlastIndexOf(Objectelem) {
returndelegate.lastIndexOf(elem);
 }

/**
 * Searches backwards for {@code elem}, starting from the
 * specified index, and returns an index to it.
 *
 * @param elem the desired component
 * @param index the index to start searching from
 * @return the index of the last occurrence of the {@code elem}
 * in this list at position less than {@code index};
 * returns {@code -1} if the object is not found
 * @see Vector#lastIndexOf(Object,int)
 */
publicintlastIndexOf(Objectelem, intindex) {
returndelegate.lastIndexOf(elem, index);
 }

/**
 * Returns the component at the specified index.
 * <blockquote>
 * <b>Note:</b> Although this method is not deprecated, the preferred
 * method to use is {@code get(int)}, which implements the
 * {@code List} interface defined in the 1.2 Collections framework.
 * </blockquote>
 *
 * @param index an index into this list
 * @return the component at the specified index
 * @throws ArrayIndexOutOfBoundsException if the index
 * is negative or not less than the size of the list
 * @see #get(int)
 * @see Vector#elementAt(int)
 */
publicEelementAt(intindex) {
returndelegate.elementAt(index);
 }

/**
 * Returns the first component of this list.
 * @return the first component of this list
 * @see Vector#firstElement()
 * @throws java.util.NoSuchElementException if this
 * vector has no components
 */
publicEfirstElement() {
returndelegate.firstElement();
 }

/**
 * Returns the last component of the list.
 *
 * @return the last component of the list
 * @see Vector#lastElement()
 * @throws java.util.NoSuchElementException if this vector
 * has no components
 */
publicElastElement() {
returndelegate.lastElement();
 }

/**
 * Sets the component at the specified {@code index} of this
 * list to be the specified element. The previous component at that
 * position is discarded.
 * <blockquote>
 * <b>Note:</b> Although this method is not deprecated, the preferred
 * method to use is {@code set(int,Object)}, which implements the
 * {@code List} interface defined in the 1.2 Collections framework.
 * </blockquote>
 *
 * @param element what the component is to be set to
 * @param index the specified index
 * @throws ArrayIndexOutOfBoundsException if the index is invalid
 * @see #set(int,Object)
 * @see Vector#setElementAt(Object,int)
 */
publicvoidsetElementAt(Eelement, intindex) {
delegate.setElementAt(element, index);
fireContentsChanged(this, index, index);
 }

/**
 * Deletes the component at the specified index.
 * <blockquote>
 * <b>Note:</b> Although this method is not deprecated, the preferred
 * method to use is {@code remove(int)}, which implements the
 * {@code List} interface defined in the 1.2 Collections framework.
 * </blockquote>
 *
 * @param index the index of the object to remove
 * @see #remove(int)
 * @see Vector#removeElementAt(int)
 * @throws ArrayIndexOutOfBoundsException if the index is invalid
 */
publicvoidremoveElementAt(intindex) {
delegate.removeElementAt(index);
fireIntervalRemoved(this, index, index);
 }

/**
 * Inserts the specified element as a component in this list at the
 * specified <code>index</code>.
 * <blockquote>
 * <b>Note:</b> Although this method is not deprecated, the preferred
 * method to use is {@code add(int,Object)}, which implements the
 * {@code List} interface defined in the 1.2 Collections framework.
 * </blockquote>
 *
 * @param element the component to insert
 * @param index where to insert the new component
 * @throws ArrayIndexOutOfBoundsException if the index was invalid
 * @see #add(int,Object)
 * @see Vector#insertElementAt(Object,int)
 */
publicvoidinsertElementAt(Eelement, intindex) {
delegate.insertElementAt(element, index);
fireIntervalAdded(this, index, index);
 }

/**
 * Adds the specified component to the end of this list.
 *
 * @param element the component to be added
 * @see Vector#addElement(Object)
 */
publicvoidaddElement(Eelement) {
intindex = delegate.size();
delegate.addElement(element);
fireIntervalAdded(this, index, index);
 }

/**
 * Removes the first (lowest-indexed) occurrence of the argument
 * from this list.
 *
 * @param obj the component to be removed
 * @return {@code true} if the argument was a component of this
 * list; {@code false} otherwise
 * @see Vector#removeElement(Object)
 */
publicbooleanremoveElement(Objectobj) {
intindex = indexOf(obj);
booleanrv = delegate.removeElement(obj);
if (index >= 0) {
fireIntervalRemoved(this, index, index);
 }
returnrv;
 }


/**
 * Removes all components from this list and sets its size to zero.
 * <blockquote>
 * <b>Note:</b> Although this method is not deprecated, the preferred
 * method to use is {@code clear}, which implements the
 * {@code List} interface defined in the 1.2 Collections framework.
 * </blockquote>
 *
 * @see #clear()
 * @see Vector#removeAllElements()
 */
publicvoidremoveAllElements() {
intindex1 = delegate.size()-1;
delegate.removeAllElements();
if (index1 >= 0) {
fireIntervalRemoved(this, 0, index1);
 }
 }


/**
 * Returns a string that displays and identifies this
 * object's properties.
 *
 * @return a String representation of this object
 */
publicStringtoString() {
returndelegate.toString();
 }


/* The remaining methods are included for compatibility with the
 * Java 2 platform Vector class.
 */

/**
 * Returns an array containing all of the elements in this list in the
 * correct order.
 *
 * @return an array containing the elements of the list
 * @see Vector#toArray()
 */
publicObject[] toArray() {
Object[] rv = newObject[delegate.size()];
delegate.copyInto(rv);
returnrv;
 }

/**
 * Returns the element at the specified position in this list.
 *
 * @param index index of element to return
 * @return the element at the specified position in this list
 * @throws ArrayIndexOutOfBoundsException if the index is out of range
 * ({@code index &lt; 0 || index &gt;= size()})
 */
publicEget(intindex) {
returndelegate.elementAt(index);
 }

/**
 * Replaces the element at the specified position in this list with the
 * specified element.
 *
 * @param index index of element to replace
 * @param element element to be stored at the specified position
 * @return the element previously at the specified position
 * @throws ArrayIndexOutOfBoundsException if the index is out of range
 * ({@code index &lt; 0 || index &gt;= size()})
 */
publicEset(intindex, Eelement) {
Erv = delegate.elementAt(index);
delegate.setElementAt(element, index);
fireContentsChanged(this, index, index);
returnrv;
 }

/**
 * Inserts the specified element at the specified position in this list.
 *
 * @param index index at which the specified element is to be inserted
 * @param element element to be inserted
 * @throws ArrayIndexOutOfBoundsException if the index is out of range
 * ({@code index &lt; 0 || index &gt; size()})
 */
publicvoidadd(intindex, Eelement) {
delegate.insertElementAt(element, index);
fireIntervalAdded(this, index, index);
 }

/**
 * Removes the element at the specified position in this list.
 * Returns the element that was removed from the list
 *
 * @param index the index of the element to removed
 * @return the element previously at the specified position
 * @throws ArrayIndexOutOfBoundsException if the index is out of range
 * ({@code index &lt; 0 || index &gt;= size()})
 */
publicEremove(intindex) {
Erv = delegate.elementAt(index);
delegate.removeElementAt(index);
fireIntervalRemoved(this, index, index);
returnrv;
 }

/**
 * Removes all of the elements from this list. The list will
 * be empty after this call returns (unless it throws an exception).
 */
publicvoidclear() {
intindex1 = delegate.size()-1;
delegate.removeAllElements();
if (index1 >= 0) {
fireIntervalRemoved(this, 0, index1);
 }
 }

/**
 * Deletes the components at the specified range of indexes.
 * The removal is inclusive, so specifying a range of (1,5)
 * removes the component at index 1 and the component at index 5,
 * as well as all components in between.
 *
 * @param fromIndex the index of the lower end of the range
 * @param toIndex the index of the upper end of the range
 * @throws ArrayIndexOutOfBoundsException if the index was invalid
 * @throws IllegalArgumentException if {@code fromIndex &gt; toIndex}
 * @see #remove(int)
 */
publicvoidremoveRange(intfromIndex, inttoIndex) {
if (fromIndex > toIndex) {
thrownewIllegalArgumentException("fromIndex must be <= toIndex");
 }
for(inti = toIndex; i >= fromIndex; i--) {
delegate.removeElementAt(i);
 }
fireIntervalRemoved(this, fromIndex, toIndex);
 }

/**
 * Adds all of the elements present in the collection to the list.
 *
 * @param c the collection which contains the elements to add
 * @throws NullPointerException if {@code c} is null
 *
 * @since 11
 */
publicvoidaddAll(Collection<? extendsE> c) {
if (c.isEmpty()) {
return;
 }

intstartIndex = getSize();

delegate.addAll(c);
fireIntervalAdded(this, startIndex, getSize() - 1);
 }

/**
 * Adds all of the elements present in the collection, starting
 * from the specified index.
 *
 * @param index index at which to insert the first element from the
 * specified collection
 * @param c the collection which contains the elements to add
 * @throws ArrayIndexOutOfBoundsException if {@code index} does not
 * fall within the range of number of elements currently held
 * @throws NullPointerException if {@code c} is null
 *
 * @since 11
 */
publicvoidaddAll(intindex, Collection<? extendsE> c) {
if (index < 0 || index > getSize()) {
thrownewArrayIndexOutOfBoundsException("index out of range: " +
index);
 }

if (c.isEmpty()) {
return;
 }

delegate.addAll(index, c);
fireIntervalAdded(this, index, index + c.size() - 1);
 }
}