baselistimpl.java

Java的面向对象数据库系统的源代码

/*
 * $Id: BaseListImpl.java,v 1.4 2003/11/20 23:18:41 per_nyfelt Exp $
 * This file is based on AbstractList.java from GNU Classpath. Quote:

AbstractList.java -- Abstract implementation of most of List
Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath 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 for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version.

 * end quote.
 *
 * This file is licenced under the same conditions as its original (GPL +
 * "special exception").
 */

package org.ozoneDB.collections;

import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.RandomAccess;

/**
 * A basic implementation of most of the methods in the List interface to make
 * it easier to create a List based on a random-access data structure. If
 * the list is sequential (such as a linked list), use AbstractSequentialList.
 * To create an unmodifiable list, it is only necessary to override the
 * size() and get(int) methods (this contrasts with all other abstract
 * collection classes which require an iterator to be provided). To make the
 * list modifiable, the set(int, Object) method should also be overridden, and
 * to make the list resizable, the add(int, Object) and remove(int) methods
 * should be overridden too. Other methods should be overridden if the
 * backing data structure allows for a more efficient implementation.
 * The precise implementation used by AbstractList is documented, so that
 * subclasses can tell which methods could be implemented more efficiently.
 * <p>
 *
 * As recommended by Collection and List, the subclass should provide at
 * least a no-argument and a Collection constructor. This class is not
 * synchronized.
 *
 * @author Original author unknown
 * @author Bryce McKinlay
 * @author Eric Blake <[e-mail]>
 * @see Collection
 * @see List
 * @see java.util.AbstractSequentialList
 * @see java.util.AbstractCollection
 * @see ListIterator
 * @since 1.2
 * @status updated to 1.4
 */
public abstract class BaseListImpl extends AbstractOzoneCollection implements BaseList {

    /**
     * A count of the number of structural modifications that have been made to
     * the list (that is, insertions and removals). Structural modifications
     * are ones which change the list size or affect how iterations would
     * behave. This field is available for use by Iterator and ListIterator,
     * in order to throw a {@link ConcurrentModificationException} in response
     * to the next operation on the iterator. This <i>fail-fast</i> behavior
     * saves the user from many subtle bugs otherwise possible from concurrent
     * modification during iteration.
     * <p>
     *
     * To make lists fail-fast, increment this field by just 1 in the
     * <code>add(int, Object)</code> and <code>remove(int)</code> methods.
     * Otherwise, this field may be ignored.
     */
    protected int modCount;

    /**
     * The main constructor, for use by subclasses.
     */
    protected BaseListImpl() {
    }

    public void add(int index, Object o) {
        throw new UnsupportedOperationException();
    }

    /**
     * Add an element to the end of the list (optional operation). If the list
     * imposes restraints on what can be inserted, such as no null elements,
     * this should be documented. This implementation calls
     * <code>add(size(), o);</code>, and will fail if that version does.
     *
     * @param o the object to add
     * @return true, as defined by Collection for a modified list
     * @throws UnsupportedOperationException if this list does not support the
     *         add operation
     * @throws ClassCastException if o cannot be added to this list due to its
     *         type
     * @throws IllegalArgumentException if o cannot be added to this list for
     *         some other reason
     * @see #add(int, Object)
     */
    public boolean add(Object o) {
        add(size(), o);
        return true;
    }

    public boolean addAll(int index, Collection c) {
        Iterator itr = c.iterator();
        int size = c.size();
        for (int pos = size; pos > 0; pos--)
            add(index++, itr.next());
        return size > 0;
    }

    /**
     * Clear the list, such that a subsequent call to isEmpty() would return
     * true (optional operation). This implementation calls
     * <code>removeRange(0, size())</code>, so it will fail unless remove
     * or removeRange is overridden.
     *
     * @throws UnsupportedOperationException if this list does not support the
     *         clear operation
     * @see #remove(int)
     * @see #_org_ozoneDB_removeRange(int, int)
     */
    public void clear() {
        _org_ozoneDB_removeRange(0, size());
    }

    /**
     * Test whether this list is equal to another object. A List is defined to be
     * equal to an object if and only if that object is also a List, and the two
     * lists have the same sequence. Two lists l1 and l2 are equal if and only
     * if <code>l1.size() == l2.size()</code>, and for every integer n between 0
     * and <code>l1.size() - 1</code> inclusive, <code>l1.get(n) == null ?
     * l2.get(n) == null : l1.get(n).equals(l2.get(n))</code>.
     * <p>
     *
     * This implementation returns true if the object is this, or false if the
     * object is not a List.  Otherwise, it iterates over both lists (with
     * iterator()), returning false if two elements compare false or one list
     * is shorter, and true if the iteration completes successfully.
     *
     * @param o the object to test for equality with this list
     * @return true if o is equal to this list
     * @see Object#equals(Object)
     * @see #hashCode()
     */
    public boolean equals(Object o) {
        if (o == this)
            return true;
        if (! (o instanceof List))
            return false;
        int size = size();
        if (size != ((List) o).size())
            return false;

        Iterator itr1 = iterator();
        Iterator itr2 = ((List) o).iterator();

        while (--size >= 0)
            if (! equals(itr1.next(), itr2.next()))
                return false;
        return true;
    }

    /**
     * Obtains a hash code for this list. In order to obey the general
     * contract of the hashCode method of class Object, this value is
     * calculated as follows:
     *
<pre>hashCode = 1;
Iterator i = list.iterator();
while (i.hasNext())
{
  Object obj = i.next();
  hashCode = 31 * hashCode + (obj == null ? 0 : obj.hashCode());
}</pre>
     *
     * This ensures that the general contract of Object.hashCode() is adhered to.
     *
     * @return the hash code of this list
     *
     * @see Object#hashCode()
     * @see #equals(Object)
     */
    public int hashCode() {
        int hashCode = 1;
        Iterator itr = iterator();
        int pos = size();
        while (--pos >= 0)
            hashCode = 31 * hashCode + hashCode(itr.next());
        return hashCode;
    }