rhodes 2.0.3 → 2.1.0

data/platform/shared/rubyJVM/src/javolution/util/FastTable.java

@@ -1,975 +0,0 @@
-/*
- * Javolution - Java(TM) Solution for Real-Time and Embedded Systems
- * Copyright (C) 2005 - Javolution (http://javolution.org/)
- * All rights reserved.
- * 
- * Permission to use, copy, modify, and distribute this software is
- * freely granted, provided that this notice is preserved.
- */
-package javolution.util;
-
-import java.io.IOException;
-import java.util.NoSuchElementException;
-
-import j2me.io.ObjectInputStream;
-import j2me.io.ObjectOutputStream;
-import j2me.lang.IllegalStateException;
-import j2me.lang.UnsupportedOperationException;
-import j2me.util.Collection;
-import j2me.util.Iterator;
-import j2me.util.List;
-import j2me.util.ListIterator;
-import j2me.util.RandomAccess;
-import j2mex.realtime.MemoryArea;
-import javolution.context.ObjectFactory;
-import javolution.context.PersistentContext;
-import javolution.lang.MathLib;
-import javolution.lang.Reusable;
-
-/**
- * <p> This class represents a random access collection with real-time behavior 
- *     (smooth capacity increase).</p>
- *     <img src="doc-files/list-add.png"/>
- *     
- * <p> This class has the following advantages over the widely used 
- *     <code>java.util.ArrayList</code>:<ul>
- *     <li> No large array allocation (for large collections multi-dimensional
- *          arrays are employed). The garbage collector is not stressed with
- *          large chunk of memory to allocate (likely to trigger a
- *          full garbage collection due to memory fragmentation).</li>
- *     <li> Support concurrent access/iteration without synchronization if the 
- *          collection values are not removed/inserted (Ref. 
- *          {@link javolution.util} discussion).</li>
- *     </ul></p>
- *     
- *  <p> Iterations over the {@link FastTable} values are faster when
- *      performed using the {@link #get} method rather than using collection
- *      records or iterators:[code]
- *     for (int i = 0, n = table.size(); i < n; i++) {
- *          table.get(i);
- *     }[/code]</p>
- *     
- *  <p> {@link FastTable} supports {@link #sort sorting} in place (quick sort) 
- *      using the {@link FastCollection#getValueComparator() value comparator}
- *      for the table (no object or array allocation when sorting).</p>
- *       
- *  <p> The size of a {@link FastTable} can be {@link #setSize set} directly
- *      and populated concurrently through the {@link #set(int, Object)} 
- *      method (e.g. table shared by multiple threads each working on 
- *      different index ranges).</p> 
- * 
- * @author <a href="mailto:jean-marie@dautelle.com">Jean-Marie Dautelle</a>
- * @version 5.2, August 20, 2007
- */
-public class FastTable/*<E>*/extends FastCollection/*<E>*/implements
-        List/*<E>*/, Reusable, RandomAccess {
-
-    /**
-     * Holds the factory for this fast table.
-     */
-    private static final ObjectFactory FACTORY = new ObjectFactory() {
-        public Object create() {
-            return new FastTable();
-        }
-
-        public void cleanup(Object obj) {
-            ((FastTable) obj).reset();
-        }
-    };
-
-    // We do a full resize (and copy) only when the capacity is less than C1.
-    // For large collections, multi-dimensional arrays are employed.
-
-    private static final int B0 = 4; // Initial capacity in bits.
-
-    private static final int C0 = 1 << B0; // Initial capacity (16)
-
-    private static final int B1 = 10; // Low array maximum capacity in bits.
-
-    private static final int C1 = 1 << B1; // Low array maximum capacity (1024).
-
-    private static final int M1 = C1 - 1; // Mask.
-
-    // Resizes up to 1024 maximum (16, 32, 64, 128, 256, 512, 1024). 
-    private transient Object/*{E}*/[] _low;
-
-    // For larger capacity use multi-dimensional array.
-    private transient Object/*{E}*/[][] _high;
-
-    /**
-     * Holds the current capacity. 
-     */
-    private transient int _capacity;
-
-    /**
-     * Holds the current size.
-     */
-    private transient int _size;
-
-    /**
-     * Holds the value comparator.
-     */
-    private transient FastComparator/*<? super E>*/_valueComparator = FastComparator.DEFAULT;
-
-    /**
-     * Creates a table of small initial capacity.
-     */
-    public FastTable() {
-        _capacity = C0;
-        _low = (Object/*{E}*/[]) new Object[C0];
-        _high = (Object/*{E}*/[][]) new Object[1][];
-        _high[0] = _low;
-    }
-
-    /**
-     * Creates a persistent table associated to the specified unique identifier
-     * (convenience method).
-     * 
-     * @param id the unique identifier for this map.
-     * @throws IllegalArgumentException if the identifier is not unique.
-     * @see javolution.context.PersistentContext.Reference
-     */
-    public FastTable(String id) {
-        this();
-        new PersistentContext.Reference(id, this) {
-            protected void notifyChange() {
-                FastTable.this.clear();
-                FastTable.this.addAll((FastList) this.get());
-            }
-        };
-    }
-
-    /**
-     * Creates a table of specified initial capacity; unless the table size 
-     * reaches the specified capacity, operations on this table will not 
-     * allocate memory (no lazy object creation).
-     * 
-     * @param capacity the initial capacity.
-     */
-    public FastTable(int capacity) {
-        this();
-        while (capacity > _capacity) {
-            increaseCapacity();
-        }
-    }
-
-    /**
-     * Creates a table containing the specified values, in the order they
-     * are returned by the collection's iterator.
-     *
-     * @param values the values to be placed into this table.
-     */
-    public FastTable(Collection/*<? extends E>*/values) {
-        this(values.size());
-        addAll(values);
-    }
-
-    /**
-     * Returns a new, preallocated or {@link #recycle recycled} table instance
-     * (on the stack when executing in a {@link javolution.context.StackContext
-     * StackContext}).
-     *
-     * @return a new, preallocated or recycled table instance.
-     */
-    public static/*<E>*/FastTable/*<E>*/newInstance() {
-        return (FastTable/*<E>*/) FACTORY.object();
-    }
-
-    /**
-     * Recycles a table {@link #newInstance() instance} immediately
-     * (on the stack when executing in a {@link javolution.context.StackContext
-     * StackContext}). 
-     */
-    public static void recycle(FastTable instance) {
-        FACTORY.recycle(instance);
-    }
-
-    /**
-     * Sets the size of this table. If the specified size is greater than
-     * the current size then <code>null</code> elements are added; otherwise
-     * the last elements are removed until the desired size is reached.
-     *
-     * @param size the new size.
-     */
-    public void setSize(int size) {
-        while (_size < size) { // Adds null elements.
-            addLast(null);
-        }
-        while (_size > size) { // Removes last elements.
-            removeLast();
-        }
-    }
-
-    /**
-     * Returns the element at the specified index.
-     *
-     * @param index index of value to return.
-     * @return the value at the specified position in this list.
-     * @throws IndexOutOfBoundsException if <code>(index < 0) || 
-     *         (index >= size())</code>
-     */
-    public final Object/*{E}*/get(int index) { // Short to be inlined.
-        if (index >= _size)
-            throw new IndexOutOfBoundsException();
-        return index < C1 ? _low[index] : _high[index >> B1][index & M1];
-    }
-
-    /**
-     * Replaces the value at the specified position in this table with the
-     * specified value.
-     *
-     * @param index index of value to replace.
-     * @param value value to be stored at the specified position.
-     * @return previous value.
-     * @throws IndexOutOfBoundsException if <code>(index < 0) || 
-     *         (index >= size())</code>
-     */
-    public final Object/*{E}*/set(int index, Object/*{E}*/value) {
-        if (index >= _size)
-            throw new IndexOutOfBoundsException();
-        final Object/*{E}*/[] low = _high[index >> B1];
-        final Object/*{E}*/previous = low[index & M1];
-        low[index & M1] = value;
-        return previous;
-    }
-
-    /**
-     * Appends the specified value to the end of this table.
-     *
-     * @param value the value to be appended to this table.
-     * @return <code>true</code> (as per the general contract of the
-     *         <code>Collection.add</code> method).
-     */
-    public final boolean add(Object/*{E}*/value) {
-        if (_size >= _capacity)
-            increaseCapacity();
-        _high[_size >> B1][_size & M1] = value;
-        _size += ONE_VOLATILE; // Prevents compiler reordering.
-        return true;
-    }
-
-    /**
-     * Returns the first value of this table.
-     *
-     * @return this table first value.
-     * @throws NoSuchElementException if this table is empty.
-     */
-    public final Object/*{E}*/getFirst() {
-        if (_size == 0)
-            throw new NoSuchElementException();
-        return _low[0];
-    }
-
-    /**
-     * Returns the last value of this table.
-     *
-     * @return this table last value.
-     * @throws NoSuchElementException if this table is empty.
-     */
-    public final Object/*{E}*/getLast() {
-        if (_size == 0)
-            throw new NoSuchElementException();
-        return get(_size - 1);
-    }
-
-    /**
-     * Appends the specified value to the end of this table <i>(fast)</i>.
-     * 
-     * @param value the value to be added.
-     */
-    public final void addLast(Object/*{E}*/value) {
-        add(value);
-    }
-
-    /**
-     * Removes and returns the last value of this table <i>(fast)</i>.
-     *
-     * @return this table's last value before this call.
-     * @throws NoSuchElementException if this table is empty.
-     */
-    public final Object/*{E}*/removeLast() {
-        if (_size == 0)
-            throw new NoSuchElementException();
-        _size--; // No need for volatile, removal are not thread-safe.
-        final Object/*{E}*/[] low = _high[_size >> B1];
-        final Object/*{E}*/previous = low[_size & M1];
-        low[_size & M1] = null;
-        return previous;
-    }
-
-    // Overrides.
-    public final void clear() {
-        for (int i = 0; i < _size; i += C1) {
-            final int count = MathLib.min(_size - i, C1);
-            final Object/*{E}*/[] low = _high[i >> B1];
-            System.arraycopy(NULL_BLOCK, 0, low, 0, count);
-        }
-        _size = 0; // No need for volatile, removal are not thread-safe.
-    }
-
-    private static final Object[] NULL_BLOCK = (Object[]) new Object[C1];
-
-    // Implements Reusable interface.
-    public void reset() {
-        clear();
-        this.setValueComparator(FastComparator.DEFAULT);
-    }
-
-    /**
-     * Inserts all of the values in the specified collection into this
-     * table at the specified position. Shifts the value currently at that
-     * position (if any) and any subsequent values to the right 
-     * (increases their indices). 
-     * 
-     * <p>Note: If this method is used concurrent access must be synchronized
-     *          (the table is no more thread-safe).</p>
-     *
-     * @param index the index at which to insert first value from the specified
-     *        collection.
-     * @param values the values to be inserted into this list.
-     * @return <code>true</code> if this list changed as a result of the call;
-     *         <code>false</code> otherwise.
-     * @throws IndexOutOfBoundsException if <code>(index < 0) || 
-     *         (index > size())</code>
-     */
-    public final boolean addAll(int index, Collection/*<? extends E>*/values) {
-        if ((index < 0) || (index > _size))
-            throw new IndexOutOfBoundsException("index: " + index);
-        final int shift = values.size();
-        shiftRight(index, shift);
-        Iterator/*<? extends E>*/valuesIterator = values.iterator();
-        for (int i = index, n = index + shift; i < n; i++) {
-            _high[i >> B1][i & M1] = valuesIterator.next();
-        }
-        _size += shift * ONE_VOLATILE; // Increases size last (thread-safe)
-        return shift != 0;
-    }
-
-    /**
-     * Inserts the specified value at the specified position in this table.
-     * Shifts the value currently at that position
-     * (if any) and any subsequent values to the right (adds one to their
-     * indices).
-     *
-     * <p>Note: If this method is used concurrent access must be synchronized
-     *          (the table is no more thread-safe).</p>
-     *
-     * @param index the index at which the specified value is to be inserted.
-     * @param value the value to be inserted.
-     * @throws IndexOutOfBoundsException if <code>(index < 0) || 
-     *         (index > size())</code>
-     */
-    public final void add(int index, Object/*{E}*/value) {
-        if ((index < 0) || (index > _size))
-            throw new IndexOutOfBoundsException("index: " + index);
-        shiftRight(index, 1);
-        _high[index >> B1][index & M1] = value;
-        _size += ONE_VOLATILE; // Increases size last (thread-safe).
-    }
-
-    /**
-     * Removes the value at the specified position from this table.
-     * Shifts any subsequent values to the left (subtracts one
-     * from their indices). Returns the value that was removed from the
-     * table.
-     *
-     * <p>Note: If this method is used concurrent access must be synchronized
-     *          (the table is no more thread-safe).</p>
-     *
-     * @param index the index of the value to removed.
-     * @return the value previously at the specified position.
-     * @throws IndexOutOfBoundsException if <code>(index < 0) || 
-     *         (index >= size())</code>
-     */
-    public final Object/*{E}*/remove(int index) {
-        final Object/*{E}*/previous = get(index);
-        shiftLeft(index + 1, 1);
-        _size--; // No need for volatile, removal are not thread-safe.
-        _high[_size >> B1][_size & M1] = null; // Deallocates for GC.
-        return previous;
-    }
-
-    /**
-     * Removes the values between <code>[fromIndex..toIndex[<code> from
-     * this table.
-     * 
-     * <p>Note: If this method is used concurrent access must be synchronized
-     *          (the table is no more thread-safe).</p>
-     *
-     * @param fromIndex the beginning index, inclusive.
-     * @param toIndex the ending index, exclusive.
-     * @throws IndexOutOfBoundsException if <code>(fromIndex < 0) || (toIndex < 0) 
-     *         || (fromIndex > toIndex) || (toIndex > this.size())</code>
-     */
-    public final void removeRange(int fromIndex, int toIndex) {
-        if ((fromIndex < 0) || (toIndex < 0) || (fromIndex > toIndex)
-                || (toIndex > _size))
-            throw new IndexOutOfBoundsException();
-        final int shift = toIndex - fromIndex;
-        shiftLeft(fromIndex, shift);
-        _size -= shift; // No need for volatile, removal are not thread-safe.        
-        for (int i = _size, n = _size + shift; i < n; i++) {
-            _high[i >> B1][i & M1] = null; // Deallocates for GC.
-        }
-    }
-
-    /**
-     * Returns the index in this table of the first occurrence of the specified
-     * value, or -1 if this table does not contain this value.
-     *
-     * @param value the value to search for.
-     * @return the index in this table of the first occurrence of the specified
-     *         value, or -1 if this table does not contain this value.
-     */
-    public final int indexOf(Object value) {
-        final FastComparator comp = this.getValueComparator();
-        for (int i = 0; i < _size;) {
-            final Object/*{E}*/[] low = _high[i >> B1];
-            final int count = MathLib.min(low.length, _size - i);
-            for (int j = 0; j < count; j++) {
-                if (comp == FastComparator.DEFAULT ? defaultEquals(value,
-                        low[j]) : comp.areEqual(value, low[j]))
-                    return i + j;
-            }
-            i += count;
-        }
-        return -1;
-    }
-
-    /**
-     * Returns the index in this table of the last occurrence of the specified
-     * value, or -1 if this table does not contain this value.
-     *
-     * @param value the value to search for.
-     * @return the index in this table of the last occurrence of the specified
-     *         value, or -1 if this table does not contain this value.
-     */
-    public final int lastIndexOf(Object value) {
-        final FastComparator comp = this.getValueComparator();
-        for (int i = _size - 1; i >= 0;) {
-            final Object/*{E}*/[] low = _high[i >> B1];
-            final int count =  (i & M1) + 1;
-            for (int j = count; --j >= 0;) {
-                if (comp == FastComparator.DEFAULT ? defaultEquals(value,
-                        low[j]) : comp.areEqual(value, low[j]))
-                    return i + j - count + 1;
-            }
-            i -= count;
-        }
-        return -1;
-    }
-
-    /**
-     * Returns an iterator over the elements in this list 
-     * (allocated on the stack when executed in a 
-     * {@link javolution.context.StackContext StackContext}).
-     *
-     * @return an iterator over this list values.
-     */
-    public Iterator/*<E>*/iterator() {
-        return FastTableIterator.valueOf(this, 0, 0, _size);
-    }
-
-    /**
-     * Returns a list iterator over the elements in this list 
-     * (allocated on the stack when executed in a 
-     * {@link javolution.context.StackContext StackContext}).
-     *
-     * @return an iterator over this list values.
-     */
-    public ListIterator/*<E>*/listIterator() {
-        return FastTableIterator.valueOf(this, 0, 0, _size);
-    }
-
-    /**
-     * Returns a list iterator from the specified position
-     * (allocated on the stack when executed in a 
-     * {@link javolution.context.StackContext StackContext}).
-     * The list iterator being returned does not support insertion/deletion.
-     * 
-     * @param index the index of first value to be returned from the
-     *        list iterator (by a call to the <code>next</code> method).
-     * @return a list iterator of the values in this table
-     *         starting at the specified position in this list.
-     * @throws IndexOutOfBoundsException if the index is out of range 
-     *         [code](index < 0 || index > size())[/code]
-     */
-    public ListIterator/*<E>*/listIterator(int index) {
-        if ((index < 0) || (index > _size)) throw new IndexOutOfBoundsException();
-        return FastTableIterator.valueOf(this, index, 0, _size);
-    }
-
-    /**
-     * Returns a view of the portion of this list between the specified
-     * indexes (instance of {@link FastList} allocated from the "stack" when
-     * executing in a {@link javolution.context.StackContext StackContext}).
-     * If the specified indexes are equal, the returned list is empty. 
-     * The returned list is backed by this list, so non-structural changes in
-     * the returned list are reflected in this list, and vice-versa. 
-     *
-     * This method eliminates the need for explicit range operations (of
-     * the sort that commonly exist for arrays). Any operation that expects
-     * a list can be used as a range operation by passing a subList view
-     * instead of a whole list.  For example, the following idiom
-     * removes a range of values from a list: [code]
-     * list.subList(from, to).clear();[/code]
-     * Similar idioms may be constructed for <code>indexOf</code> and
-     * <code>lastIndexOf</code>, and all of the algorithms in the
-     * <code>Collections</code> class can be applied to a subList.
-     *
-     * The semantics of the list returned by this method become undefined if
-     * the backing list (i.e., this list) is <i>structurally modified</i> in
-     * any way other than via the returned list (structural modifications are
-     * those that change the size of this list, or otherwise perturb it in such
-     * a fashion that iterations in progress may yield incorrect results).
-     *
-     * @param fromIndex low endpoint (inclusive) of the subList.
-     * @param toIndex high endpoint (exclusive) of the subList.
-     * @return a view of the specified range within this list.
-     * 
-     * @throws IndexOutOfBoundsException if [code](fromIndex < 0 ||
-     *          toIndex > size || fromIndex > toIndex)[/code]
-     */
-    public final List/*<E>*/subList(int fromIndex, int toIndex) {
-        if ((fromIndex < 0) || (toIndex > _size) || (fromIndex > toIndex))
-            throw new IndexOutOfBoundsException("fromIndex: " + fromIndex
-                    + ", toIndex: " + toIndex + " for list of size: " + _size);
-        int size = toIndex - fromIndex;
-        FastTable table = new FastTable(size);
-        
-        for( int i = fromIndex; i < size; i++ )
-        	table.add(this.get(i));
-        	
-        return table;
-//RHO    
-        //return SubTable.valueOf(this, fromIndex, toIndex - fromIndex);
-//RHO        
-    }
-
-    /**
-     * Reduces the capacity of this table to the current size (minimize 
-     * storage space).
-     */
-    public final void trimToSize() {
-        while (_capacity - _size > C1) {
-            _capacity -= C1;
-            _high[_capacity >> B1] = null;
-        }
-    }
-
-    /**
-     * Sorts this table in place (quick sort) using this table 
-     * {@link FastCollection#getValueComparator() value comparator}
-     * (smallest first).
-     * 
-     * @return <code>this</code>
-     */
-    public final FastTable/*<E>*/sort() {
-        if (_size > 1) {
-            quicksort(0, _size - 1, this.getValueComparator());
-        }
-        return this;
-    }
-
-    // From Wikipedia Quick Sort - http://en.wikipedia.org/wiki/Quicksort
-    //
-    private void quicksort(int first, int last, FastComparator cmp) {
-        int pivIndex = 0;
-        if (first < last) {
-            pivIndex = partition(first, last, cmp);
-            quicksort(first, (pivIndex - 1), cmp);
-            quicksort((pivIndex + 1), last, cmp);
-        }
-    }
-
-    private int partition(int f, int l, FastComparator cmp) {
-        int up, down;
-        Object/*{E}*/piv = get(f);
-        up = f;
-        down = l;
-        do {
-            while (cmp.compare(get(up), piv) <= 0 && up < l) {
-                up++;
-            }
-            while (cmp.compare(get(down), piv) > 0 && down > f) {
-                down--;
-            }
-            if (up < down) { // Swaps.
-                Object/*{E}*/temp = get(up);
-                set(up, get(down));
-                set(down, temp);
-            }
-        } while (down > up);
-        set(f, get(down));
-        set(down, piv);
-        return down;
-    }
-
-    /**
-     * Sets the comparator to use for value equality or comparison if the 
-     * collection is ordered (see {@link #sort()}).
-     *
-     * @param comparator the value comparator.
-     * @return <code>this</code>
-     */
-    public FastTable/*<E>*/setValueComparator(
-            FastComparator/*<? super E>*/comparator) {
-        _valueComparator = comparator;
-        return this;
-    }
-
-    // Overrides.
-    public FastComparator/*<? super E>*/getValueComparator() {
-        return _valueComparator;
-    }
-
-    // Implements FastCollection abstract method.
-    public final int size() {
-        return _size;
-    }
-
-    // Implements FastCollection abstract method.
-    public final Record head() {
-        return Index.valueOf(-1);
-    }
-
-    // Implements FastCollection abstract method.
-    public final Record tail() {
-        return Index.valueOf(_size);
-    }
-
-    // Implements FastCollection abstract method.
-    public final Object/*{E}*/valueOf(Record record) {
-        return get(((Index) record).intValue());
-    }
-
-    // Implements FastCollection abstract method.
-    public final void delete(Record record) {
-        remove(((Index) record).intValue());
-    }
-
-    // Overrides  to return a list (JDK1.5+).
-    public Collection/*List<E>*/unmodifiable() {
-        return (Collection/*List<E>*/) super.unmodifiable();
-    }
-
-    // Overrides (optimization).
-    public final boolean contains(Object value) {
-        return indexOf(value) >= 0;
-    }
-
-    // Requires special handling during de-serialization process.
-    private void readObject(ObjectInputStream stream) throws IOException,
-            ClassNotFoundException {
-        setValueComparator((FastComparator) stream.readObject());
-        final int size = stream.readInt();
-        _capacity = C0;
-        while ((_capacity < _size) && (_capacity < C1)) {
-            _capacity <<= 1; // Increases capacity up to C1 to avoid resizes.
-        }
-        _low = (Object/*{E}*/[]) new Object[_capacity];
-        _high = (Object/*{E}*/[][]) new Object[1][];
-        _high[0] = _low;
-        for (int i = 0; i < size; i++) {
-            addLast((Object/*{E}*/) stream.readObject());
-        }
-    }
-
-    // Requires special handling during serialization process.
-    private void writeObject(ObjectOutputStream stream) throws IOException {
-        stream.writeObject(getValueComparator());
-        final int size = _size;
-        stream.writeInt(size);
-        for (int i = 0; i < size; i++) {
-            stream.writeObject(get(i));
-        }
-    }
-
-    /**
-     * Returns the current capacity of this table.
-     *
-     * @return this table's capacity.
-     */
-    protected final int getCapacity() {
-        return _capacity;
-    }
-
-    /**
-     * Increases this table capacity.
-     */
-    private void increaseCapacity() {
-        MemoryArea.getMemoryArea(this).executeInArea(new Runnable() {
-            public void run() {
-                if (_capacity < C1) { // For small capacity, resize.
-                    _capacity <<= 1;
-                    Object/*{E}*/[] tmp = (Object/*{E}*/[]) new Object[_capacity];
-                    System.arraycopy(_low, 0, tmp, 0, _low.length);
-                    _low = tmp;
-                    _high[0] = tmp;
-                } else { // Add a new low block of 1024 elements.
-                    int j = _capacity >> B1;
-                    if (j >= _high.length) { // Resizes _high.
-                        Object/*{E}*/[][] tmp = (Object/*{E}*/[][]) new Object[_high.length * 2][];
-                        System.arraycopy(_high, 0, tmp, 0, _high.length);
-                        _high = tmp;
-                    }
-                    _high[j] = (Object/*{E}*/[]) new Object[C1];
-                    _capacity += C1;
-                }
-            }
-        });
-    }
-
-    /**
-     * This inner class implements a sub-table.
-     */
-/*    
-    private static final class SubTable extends FastCollection implements List,
-            RandomAccess {
-
-        private static final ObjectFactory FACTORY = new ObjectFactory() {
-            protected Object create() {
-                return new SubTable();
-            }
-
-            protected void cleanup(Object obj) {
-                SubTable st = (SubTable) obj;
-                st._table = null;
-            }
-        };
-
-        private FastTable _table;
-
-        private int _offset;
-
-        private int _size;
-
-        public static SubTable valueOf(FastTable table, int offset, int size) {
-            SubTable subTable = (SubTable) FACTORY.object();
-            subTable._table = table;
-            subTable._offset = offset;
-            subTable._size = size;
-            return subTable;
-        }
-
-        public int size() {
-            return _size;
-        }
-
-        public Record head() {
-            return Index.valueOf(-1);
-        }
-
-        public Record tail() {
-            return Index.valueOf(_size);
-        }
-
-        public Object valueOf(Record record) {
-            return _table.get(((Index) record).intValue() + _offset);
-        }
-
-        public void delete(Record record) {
-            throw new UnsupportedOperationException(
-                    "Deletion not supported, thread-safe collections.");
-        }
-
-        public boolean addAll(int index, Collection values) {
-            throw new UnsupportedOperationException(
-                    "Insertion not supported, thread-safe collections.");
-        }
-
-        public Object get(int index) {
-            if ((index < 0) || (index >= _size))
-                throw new IndexOutOfBoundsException("index: " + index);
-            return _table.get(index + _offset);
-        }
-
-        public Object set(int index, Object value) {
-            if ((index < 0) || (index >= _size))
-                throw new IndexOutOfBoundsException("index: " + index);
-            return _table.set(index + _offset, value);
-        }
-
-        public void add(int index, Object element) {
-            throw new UnsupportedOperationException(
-                    "Insertion not supported, thread-safe collections.");
-        }
-
-        public Object remove(int index) {
-            throw new UnsupportedOperationException(
-                    "Deletion not supported, thread-safe collections.");
-        }
-
-        public int indexOf(Object value) {
-            final FastComparator comp = _table.getValueComparator();
-            for (int i = -1; ++i < _size;) {
-                if (comp.areEqual(value, _table.get(i + _offset)))
-                    return i;
-            }
-            return -1;
-        }
-
-        public int lastIndexOf(Object value) {
-            final FastComparator comp = _table.getValueComparator();
-            for (int i = _size; --i >= 0;) {
-                if (comp.areEqual(value, _table.get(i + _offset)))
-                    return i;
-            }
-            return -1;
-        }
-
-        public ListIterator listIterator() {
-            return listIterator(0);
-        }
-
-        public ListIterator listIterator(int index) {
-            if ((index >= 0) && (index <= _size)) {
-                return FastTableIterator.valueOf(_table, index + _offset,
-                        _offset, _offset + _size);
-            } else {
-                throw new IndexOutOfBoundsException("index: " + index
-                        + " for table of size: " + _size);
-            }
-        }
-
-        public List subList(int fromIndex, int toIndex) {
-            if ((fromIndex < 0) || (toIndex > _size) || (fromIndex > toIndex))
-                throw new IndexOutOfBoundsException("fromIndex: " + fromIndex
-                        + ", toIndex: " + toIndex + " for list of size: "
-                        + _size);
-            return SubTable.valueOf(_table, _offset + fromIndex, toIndex
-                    - fromIndex);
-        }
-    }*/
-
-    /**
-     * This inner class implements a fast table iterator.
-     */
-    private static final class FastTableIterator implements ListIterator {
-
-        private static final ObjectFactory FACTORY = new ObjectFactory() {
-            protected Object create() {
-                return new FastTableIterator();
-            }
-
-            protected void cleanup(Object obj) {
-                FastTableIterator i = (FastTableIterator) obj;
-                i._table = null;
-                i._low = null;
-                i._high = null;
-            }
-        };
-
-        private FastTable _table;
-
-        private int _currentIndex;
-
-        private int _start; // Inclusive.
-
-        private int _end; // Exclusive.
-
-        private int _nextIndex;
-
-        private Object[] _low;
-        
-        private Object[][] _high;
-
-        public static FastTableIterator valueOf(FastTable table, int nextIndex,
-                int start, int end) {
-            FastTableIterator iterator = (FastTableIterator) FACTORY.object();
-            iterator._table = table;
-            iterator._start = start;
-            iterator._end = end;
-            iterator._nextIndex = nextIndex;
-            iterator._low = table._low;
-            iterator._high = table._high;            
-            iterator._currentIndex = -1;
-            return iterator;
-        }
-
-        public boolean hasNext() {
-            return (_nextIndex != _end);
-        }
-
-        public Object next() {
-            if (_nextIndex == _end)
-                throw new NoSuchElementException();
-            final int i = _currentIndex = _nextIndex++;
-            return i < C1 ? _low[i] : _high[i >> B1][i & M1];
-        }
-
-        public int nextIndex() {
-            return _nextIndex;
-        }
-
-        public boolean hasPrevious() {
-            return _nextIndex != _start;
-        }
-
-        public Object previous() {
-            if (_nextIndex == _start)
-                throw new NoSuchElementException();
-            final int i = _currentIndex = --_nextIndex;
-            return i < C1 ? _low[i] : _high[i >> B1][i & M1];
-        }
-
-        public int previousIndex() {
-            return _nextIndex - 1;
-        }
-
-        public void add(Object o) {
-            _table.add(_nextIndex++, o);
-            _end++;
-            _currentIndex = -1;
-        }
-
-        public void set(Object o) {
-            if (_currentIndex >= 0) {
-                _table.set(_currentIndex, o);
-            } else {
-                throw new IllegalStateException();
-            }
-        }
-
-        public void remove() {
-            if (_currentIndex >= 0) {
-                _table.remove(_currentIndex);
-                _end--;
-                if (_currentIndex < _nextIndex) {
-                    _nextIndex--;
-                }
-                _currentIndex = -1;
-            } else {
-                throw new IllegalStateException();
-            }
-        }
-    }
-
-    // Shifts element from the specified index to the right (higher indexes). 
-    private void shiftRight(int index, int shift) {
-        while (_size + shift >= _capacity) {
-            increaseCapacity();
-        }
-        for (int i = _size; --i >= index;) {
-            final int dest = i + shift;
-            _high[dest >> B1][dest & M1] = _high[i >> B1][i & M1];
-        }
-    }
-
-    // Shifts element from the specified index to the left (lower indexes). 
-    private void shiftLeft(int index, int shift) {
-        for (int i = index; i < _size; i++) {
-            final int dest = i - shift;
-            _high[dest >> B1][dest & M1] = _high[i >> B1][i & M1];
-        }
-    }
-
-    // For inlining of default comparator. 
-    private static boolean defaultEquals(Object o1, Object o2) {
-        return (o1 == null) ? (o2 == null) : (o1 == o2) || o1.equals(o2);
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    static volatile int ONE_VOLATILE = 1; // To prevent reordering.
-}