src/org/apache/xml/utils/SuballocatedIntVector.java - xalan-j - Git at Google

 /*
  * The Apache Software License, Version 1.1
  *
  *
  * Copyright (c) 1999-2003 The Apache Software Foundation.  All rights
  * reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
  *
  * 3. The end-user documentation included with the redistribution,
  *    if any, must include the following acknowledgment:
  *       "This product includes software developed by the
  *        Apache Software Foundation (http://www.apache.org/)."
  *    Alternately, this acknowledgment may appear in the software itself,
  *    if and wherever such third-party acknowledgments normally appear.
  *
  * 4. The names "Xalan" and "Apache Software Foundation" must
  *    not be used to endorse or promote products derived from this
  *    software without prior written permission. For written
  *    permission, please contact apache@apache.org.
  *
  * 5. Products derived from this software may not be called "Apache",
  *    nor may "Apache" appear in their name, without prior written
  *    permission of the Apache Software Foundation.
  *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * ====================================================================
  *
  * This software consists of voluntary contributions made by many
  * individuals on behalf of the Apache Software Foundation and was
  * originally based on software copyright (c) 1999, Lotus
  * Development Corporation., http://www.lotus.com.  For more
  * information on the Apache Software Foundation, please see
  * <http://www.apache.org/>.
  */
 package org.apache.xml.utils;

 /**
  * <meta name="usage" content="internal"/>
  * A very simple table that stores a list of int. Very similar API to our
  * IntVector class (same API); different internal storage.
  *
  * This version uses an array-of-arrays solution. Read/write access is thus
  * a bit slower than the simple IntVector, and basic storage is a trifle
  * higher due to the top-level array -- but appending is O(1) fast rather
  * than O(N**2) slow, which will swamp those costs in situations where
  * long vectors are being built up.
  *
  * Known issues:
  *
  * Some methods are private because they haven't yet been tested properly.
  *
  * Retrieval performance is critical, since this is used at the core
  * of the DTM model. (Append performance is almost as important.)
  * That's pushing me toward just letting reads from unset indices
  * throw exceptions or return stale data; safer behavior would have
  * performance costs.
  * */
 public class SuballocatedIntVector
 {
   /** Size of blocks to allocate          */
   protected int m_blocksize;

   /** Bitwise addressing (much faster than div/remainder */
   protected int m_SHIFT, m_MASK;

   /** Number of blocks to (over)allocate by */
   protected  int m_numblocks=32;

   /** Array of arrays of ints          */
   protected int m_map[][];

   /** Number of ints in array          */
   protected int m_firstFree = 0;

   /** "Shortcut" handle to m_map[0]. Surprisingly helpful for short vectors. */
   protected int m_map0[];


   /**
    * Default constructor.  Note that the default
    * block size is currently 2K, which may be overkill for
    * small lists and undershootng for large ones.
    */
   public SuballocatedIntVector()
   {
     this(2048);
   }

   /**
    * Construct a IntVector, using the given block size. For
    * efficiency, we will round the requested size off to a power of
    * two.
    *
    * @param blocksize Size of block to allocate
    * */
   public SuballocatedIntVector(int blocksize)
   {
     //m_blocksize = blocksize;
     for(m_SHIFT=0;0!=(blocksize>>>=1);++m_SHIFT)
       ;
     m_blocksize=1<<m_SHIFT;
     m_MASK=m_blocksize-1;

     m_map0=new int[m_blocksize];
     m_map = new int[m_numblocks][];
     m_map[0]=m_map0;
   }

   /** We never _did_ use the increasesize parameter, so I'm phasing
    * this constructor out.
    *
    * @deprecated use SuballocatedIntVector(int)
    * @see SuballocatedIntVector(int)
    * */
   public SuballocatedIntVector(int blocksize,int increasesize)
   {
     this(blocksize);
   }

   /**
    * Get the length of the list.
    *
    * @return length of the list
    */
   public int size()
   {
     return m_firstFree;
   }

   /**
    * Set the length of the list. This will only work to truncate the list, and
    * even then it has not been heavily tested and may not be trustworthy.
    *
    * @return length of the list
    */
   public void setSize(int sz)
   {
     if(m_firstFree>sz) // Whups; had that backward!
       m_firstFree = sz;
   }

   /**
    * Append a int onto the vector.
    *
    * @param value Int to add to the list
    */
   public  void addElement(int value)
   {
     if(m_firstFree<m_blocksize)
       m_map0[m_firstFree++]=value;
     else
     {
       // Growing the outer array should be rare. We initialize to a
       // total of m_blocksize squared elements, which at the default
       // size is 4M integers... and we grow by at least that much each
       // time.  However, attempts to microoptimize for this (assume
       // long enough and catch exceptions) yield no noticable
       // improvement.

       int index=m_firstFree>>>m_SHIFT;
       int offset=m_firstFree&m_MASK;

       if(index>=m_map.length)
       {
 	int newsize=index+m_numblocks;
 	int[][] newMap=new int[newsize][];
 	System.arraycopy(m_map, 0, newMap, 0, m_map.length);
 	m_map=newMap;
       }
       int[] block=m_map[index];
       if(null==block)
 	block=m_map[index]=new int[m_blocksize];
       block[offset]=value;

       ++m_firstFree;
     }
   }

   /**
    * Append several int values onto the vector.
    *
    * @param value Int to add to the list
    */
   private  void addElements(int value, int numberOfElements)
   {
     if(m_firstFree+numberOfElements<m_blocksize)
       for (int i = 0; i < numberOfElements; i++)
       {
         m_map0[m_firstFree++]=value;
       }
     else
     {
       int index=m_firstFree>>>m_SHIFT;
       int offset=m_firstFree&m_MASK;
       m_firstFree+=numberOfElements;
       while( numberOfElements>0)
       {
         if(index>=m_map.length)
         {
           int newsize=index+m_numblocks;
           int[][] newMap=new int[newsize][];
           System.arraycopy(m_map, 0, newMap, 0, m_map.length);
           m_map=newMap;
         }
         int[] block=m_map[index];
         if(null==block)
           block=m_map[index]=new int[m_blocksize];
         int copied=(m_blocksize-offset < numberOfElements)
           ? m_blocksize-offset : numberOfElements;
         numberOfElements-=copied;
         while(copied-- > 0)
           block[offset++]=value;

         ++index;offset=0;
       }
     }
   }

   /**
    * Append several slots onto the vector, but do not set the values.
    * Note: "Not Set" means the value is unspecified.
    *
    * @param value Int to add to the list
    */
   private  void addElements(int numberOfElements)
   {
     int newlen=m_firstFree+numberOfElements;
     if(newlen>m_blocksize)
     {
       int index=m_firstFree>>>m_SHIFT;
       int newindex=(m_firstFree+numberOfElements)>>>m_SHIFT;
       for(int i=index+1;i<=newindex;++i)
         m_map[i]=new int[m_blocksize];
     }
     m_firstFree=newlen;
   }

   /**
    * Inserts the specified node in this vector at the specified index.
    * Each component in this vector with an index greater or equal to
    * the specified index is shifted upward to have an index one greater
    * than the value it had previously.
    *
    * Insertion may be an EXPENSIVE operation!
    *
    * @param value Int to insert
    * @param at Index of where to insert
    */
   private  void insertElementAt(int value, int at)
   {
     if(at==m_firstFree)
       addElement(value);
     else if (at>m_firstFree)
     {
       int index=at>>>m_SHIFT;
       if(index>=m_map.length)
       {
         int newsize=index+m_numblocks;
         int[][] newMap=new int[newsize][];
         System.arraycopy(m_map, 0, newMap, 0, m_map.length);
         m_map=newMap;
       }
       int[] block=m_map[index];
       if(null==block)
         block=m_map[index]=new int[m_blocksize];
       int offset=at&m_MASK;
           block[offset]=value;
           m_firstFree=offset+1;
         }
     else
     {
       int index=at>>>m_SHIFT;
       int maxindex=m_firstFree>>>m_SHIFT; // %REVIEW% (m_firstFree+1?)
       ++m_firstFree;
       int offset=at&m_MASK;
       int push;

       // ***** Easier to work down from top?
       while(index<=maxindex)
       {
         int copylen=m_blocksize-offset-1;
         int[] block=m_map[index];
         if(null==block)
         {
           push=0;
           block=m_map[index]=new int[m_blocksize];
         }
         else
         {
           push=block[m_blocksize-1];
           System.arraycopy(block, offset , block, offset+1, copylen);
         }
         block[offset]=value;
         value=push;
         offset=0;
         ++index;
       }
     }
   }

   /**
    * Wipe it out. Currently defined as equivalent to setSize(0).
    */
   public void removeAllElements()
   {
     m_firstFree = 0;
   }

   /**
    * Removes the first occurrence of the argument from this vector.
    * If the object is found in this vector, each component in the vector
    * with an index greater or equal to the object's index is shifted
    * downward to have an index one smaller than the value it had
    * previously.
    *
    * @param s Int to remove from array
    *
    * @return True if the int was removed, false if it was not found
    */
   private  boolean removeElement(int s)
   {
     int at=indexOf(s,0);
     if(at<0)
       return false;
     removeElementAt(at);
     return true;
   }

   /**
    * Deletes the component at the specified index. Each component in
    * this vector with an index greater or equal to the specified
    * index is shifted downward to have an index one smaller than
    * the value it had previously.
    *
    * @param i index of where to remove and int
    */
   private  void removeElementAt(int at)
   {
         // No point in removing elements that "don't exist"...
     if(at<m_firstFree)
     {
       int index=at>>>m_SHIFT;
       int maxindex=m_firstFree>>>m_SHIFT;
       int offset=at&m_MASK;

       while(index<=maxindex)
       {
         int copylen=m_blocksize-offset-1;
         int[] block=m_map[index];
         if(null==block)
           block=m_map[index]=new int[m_blocksize];
         else
           System.arraycopy(block, offset+1, block, offset, copylen);
         if(index<maxindex)
         {
           int[] next=m_map[index+1];
           if(next!=null)
             block[m_blocksize-1]=(next!=null) ? next[0] : 0;
         }
         else
           block[m_blocksize-1]=0;
         offset=0;
         ++index;
       }
     }
     --m_firstFree;
   }

   /**
    * Sets the component at the specified index of this vector to be the
    * specified object. The previous component at that position is discarded.
    *
    * The index must be a value greater than or equal to 0 and less
    * than the current size of the vector.
    *
    * @param node object to set
    * @param index Index of where to set the object
    */
   public void setElementAt(int value, int at)
   {
     if(at<m_blocksize)
       m_map0[at]=value;
     else
     {
       int index=at>>>m_SHIFT;
       int offset=at&m_MASK;

       if(index>=m_map.length)
       {
 	int newsize=index+m_numblocks;
 	int[][] newMap=new int[newsize][];
 	System.arraycopy(m_map, 0, newMap, 0, m_map.length);
 	m_map=newMap;
       }

       int[] block=m_map[index];
       if(null==block)
 	block=m_map[index]=new int[m_blocksize];
       block[offset]=value;
     }

     if(at>=m_firstFree)
       m_firstFree=at+1;
   }


   /**
    * Get the nth element. This is often at the innermost loop of an
    * application, so performance is critical.
    *
    * @param i index of value to get
    *
    * @return value at given index. If that value wasn't previously set,
    * the result is undefined for performance reasons. It may throw an
    * exception (see below), may return zero, or (if setSize has previously
    * been used) may return stale data.
    *
    * @throw ArrayIndexOutOfBoundsException if the index was _clearly_
    * unreasonable (negative, or past the highest block).
    *
    * @throw NullPointerException if the index points to a block that could
    * have existed (based on the highest index used) but has never had anything
    * set into it.
    * %REVIEW% Could add a catch to create the block in that case, or return 0.
    * Try/Catch is _supposed_ to be nearly free when not thrown to. Do we
    * believe that? Should we have a separate safeElementAt?
    */
   public int elementAt(int i)
   {
     // This is actually a significant optimization!
     if(i<m_blocksize)
       return m_map0[i];

     return m_map[i>>>m_SHIFT][i&m_MASK];
   }

   /**
    * Tell if the table contains the given node.
    *
    * @param s object to look for
    *
    * @return true if the object is in the list
    */
   private  boolean contains(int s)
   {
     return (indexOf(s,0) >= 0);
   }

   /**
    * Searches for the first occurence of the given argument,
    * beginning the search at index, and testing for equality
    * using the equals method.
    *
    * @param elem object to look for
    * @param index Index of where to begin search
    * @return the index of the first occurrence of the object
    * argument in this vector at position index or later in the
    * vector; returns -1 if the object is not found.
    */
   public int indexOf(int elem, int index)
   {
         if(index>=m_firstFree)
                 return -1;

     int bindex=index>>>m_SHIFT;
     int boffset=index&m_MASK;
     int maxindex=m_firstFree>>>m_SHIFT;
     int[] block;

     for(;bindex<maxindex;++bindex)
     {
       block=m_map[bindex];
       if(block!=null)
         for(int offset=boffset;offset<m_blocksize;++offset)
           if(block[offset]==elem)
             return offset+bindex*m_blocksize;
       boffset=0; // after first
     }
     // Last block may need to stop before end
     int maxoffset=m_firstFree&m_MASK;
     block=m_map[maxindex];
     for(int offset=boffset;offset<maxoffset;++offset)
       if(block[offset]==elem)
         return offset+maxindex*m_blocksize;

     return -1;
   }

   /**
    * Searches for the first occurence of the given argument,
    * beginning the search at index, and testing for equality
    * using the equals method.
    *
    * @param elem object to look for
    * @return the index of the first occurrence of the object
    * argument in this vector at position index or later in the
    * vector; returns -1 if the object is not found.
    */
   public int indexOf(int elem)
   {
     return indexOf(elem,0);
   }

   /**
    * Searches for the first occurence of the given argument,
    * beginning the search at index, and testing for equality
    * using the equals method.
    *
    * @param elem Object to look for
    * @return the index of the first occurrence of the object
    * argument in this vector at position index or later in the
    * vector; returns -1 if the object is not found.
    */
   private  int lastIndexOf(int elem)
   {
     int boffset=m_firstFree&m_MASK;
     for(int index=m_firstFree>>>m_SHIFT;
         index>=0;
         --index)
     {
       int[] block=m_map[index];
       if(block!=null)
         for(int offset=boffset; offset>=0; --offset)
           if(block[offset]==elem)
             return offset+index*m_blocksize;
       boffset=0; // after first
     }
     return -1;
   }

 }
	/*
	* The Apache Software License, Version 1.1
	*
	*
	* Copyright (c) 1999-2003 The Apache Software Foundation. All rights
	* reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	*
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	*
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in
	* the documentation and/or other materials provided with the
	* distribution.
	*
	* 3. The end-user documentation included with the redistribution,
	* if any, must include the following acknowledgment:
	* "This product includes software developed by the
	* Apache Software Foundation (http://www.apache.org/)."
	* Alternately, this acknowledgment may appear in the software itself,
	* if and wherever such third-party acknowledgments normally appear.
	*
	* 4. The names "Xalan" and "Apache Software Foundation" must
	* not be used to endorse or promote products derived from this
	* software without prior written permission. For written
	* permission, please contact apache@apache.org.
	*
	* 5. Products derived from this software may not be called "Apache",
	* nor may "Apache" appear in their name, without prior written
	* permission of the Apache Software Foundation.
	*
	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	* SUCH DAMAGE.
	* ====================================================================
	*
	* This software consists of voluntary contributions made by many
	* individuals on behalf of the Apache Software Foundation and was
	* originally based on software copyright (c) 1999, Lotus
	* Development Corporation., http://www.lotus.com. For more
	* information on the Apache Software Foundation, please see
	* <http://www.apache.org/>.
	*/
	package org.apache.xml.utils;

	/**
	* <meta name="usage" content="internal"/>
	* A very simple table that stores a list of int. Very similar API to our
	* IntVector class (same API); different internal storage.
	*
	* This version uses an array-of-arrays solution. Read/write access is thus
	* a bit slower than the simple IntVector, and basic storage is a trifle
	* higher due to the top-level array -- but appending is O(1) fast rather
	* than O(N**2) slow, which will swamp those costs in situations where
	* long vectors are being built up.
	*
	* Known issues:
	*
	* Some methods are private because they haven't yet been tested properly.
	*
	* Retrieval performance is critical, since this is used at the core
	* of the DTM model. (Append performance is almost as important.)
	* That's pushing me toward just letting reads from unset indices
	* throw exceptions or return stale data; safer behavior would have
	* performance costs.
	* */
	public class SuballocatedIntVector
	{
	/** Size of blocks to allocate */
	protected int m_blocksize;

	/** Bitwise addressing (much faster than div/remainder */
	protected int m_SHIFT, m_MASK;

	/** Number of blocks to (over)allocate by */
	protected int m_numblocks=32;

	/** Array of arrays of ints */
	protected int m_map[][];

	/** Number of ints in array */
	protected int m_firstFree = 0;

	/** "Shortcut" handle to m_map[0]. Surprisingly helpful for short vectors. */
	protected int m_map0[];


	/**
	* Default constructor. Note that the default
	* block size is currently 2K, which may be overkill for
	* small lists and undershootng for large ones.
	*/
	public SuballocatedIntVector()
	{
	this(2048);
	}

	/**
	* Construct a IntVector, using the given block size. For
	* efficiency, we will round the requested size off to a power of
	* two.
	*
	* @param blocksize Size of block to allocate
	* */
	public SuballocatedIntVector(int blocksize)
	{
	//m_blocksize = blocksize;
	for(m_SHIFT=0;0!=(blocksize>>>=1);++m_SHIFT)
	;
	m_blocksize=1<<m_SHIFT;
	m_MASK=m_blocksize-1;

	m_map0=new int[m_blocksize];
	m_map = new int[m_numblocks][];
	m_map[0]=m_map0;
	}

	/** We never _did_ use the increasesize parameter, so I'm phasing
	* this constructor out.
	*
	* @deprecated use SuballocatedIntVector(int)
	* @see SuballocatedIntVector(int)
	* */
	public SuballocatedIntVector(int blocksize,int increasesize)
	{
	this(blocksize);
	}

	/**
	* Get the length of the list.
	*
	* @return length of the list
	*/
	public int size()
	{
	return m_firstFree;
	}

	/**
	* Set the length of the list. This will only work to truncate the list, and
	* even then it has not been heavily tested and may not be trustworthy.
	*
	* @return length of the list
	*/
	public void setSize(int sz)
	{
	if(m_firstFree>sz) // Whups; had that backward!
	m_firstFree = sz;
	}

	/**
	* Append a int onto the vector.
	*
	* @param value Int to add to the list
	*/
	public void addElement(int value)
	{
	if(m_firstFree<m_blocksize)
	m_map0[m_firstFree++]=value;
	else
	{
	// Growing the outer array should be rare. We initialize to a
	// total of m_blocksize squared elements, which at the default
	// size is 4M integers... and we grow by at least that much each
	// time. However, attempts to microoptimize for this (assume
	// long enough and catch exceptions) yield no noticable
	// improvement.

	int index=m_firstFree>>>m_SHIFT;
	int offset=m_firstFree&m_MASK;

	if(index>=m_map.length)
	{
	int newsize=index+m_numblocks;
	int[][] newMap=new int[newsize][];
	System.arraycopy(m_map, 0, newMap, 0, m_map.length);
	m_map=newMap;
	}
	int[] block=m_map[index];
	if(null==block)
	block=m_map[index]=new int[m_blocksize];
	block[offset]=value;

	++m_firstFree;
	}
	}

	/**
	* Append several int values onto the vector.
	*
	* @param value Int to add to the list
	*/
	private void addElements(int value, int numberOfElements)
	{
	if(m_firstFree+numberOfElements<m_blocksize)
	for (int i = 0; i < numberOfElements; i++)
	{
	m_map0[m_firstFree++]=value;
	}
	else
	{
	int index=m_firstFree>>>m_SHIFT;
	int offset=m_firstFree&m_MASK;
	m_firstFree+=numberOfElements;
	while( numberOfElements>0)
	{
	if(index>=m_map.length)
	{
	int newsize=index+m_numblocks;
	int[][] newMap=new int[newsize][];
	System.arraycopy(m_map, 0, newMap, 0, m_map.length);
	m_map=newMap;
	}
	int[] block=m_map[index];
	if(null==block)
	block=m_map[index]=new int[m_blocksize];
	int copied=(m_blocksize-offset < numberOfElements)
	? m_blocksize-offset : numberOfElements;
	numberOfElements-=copied;
	while(copied-- > 0)
	block[offset++]=value;

	++index;offset=0;
	}
	}
	}

	/**
	* Append several slots onto the vector, but do not set the values.
	* Note: "Not Set" means the value is unspecified.
	*
	* @param value Int to add to the list
	*/
	private void addElements(int numberOfElements)
	{
	int newlen=m_firstFree+numberOfElements;
	if(newlen>m_blocksize)
	{
	int index=m_firstFree>>>m_SHIFT;
	int newindex=(m_firstFree+numberOfElements)>>>m_SHIFT;
	for(int i=index+1;i<=newindex;++i)
	m_map[i]=new int[m_blocksize];
	}
	m_firstFree=newlen;
	}

	/**
	* Inserts the specified node in this vector at the specified index.
	* Each component in this vector with an index greater or equal to
	* the specified index is shifted upward to have an index one greater
	* than the value it had previously.
	*
	* Insertion may be an EXPENSIVE operation!
	*
	* @param value Int to insert
	* @param at Index of where to insert
	*/
	private void insertElementAt(int value, int at)
	{
	if(at==m_firstFree)
	addElement(value);
	else if (at>m_firstFree)
	{
	int index=at>>>m_SHIFT;
	if(index>=m_map.length)
	{
	int newsize=index+m_numblocks;
	int[][] newMap=new int[newsize][];
	System.arraycopy(m_map, 0, newMap, 0, m_map.length);
	m_map=newMap;
	}
	int[] block=m_map[index];
	if(null==block)
	block=m_map[index]=new int[m_blocksize];
	int offset=at&m_MASK;
	block[offset]=value;
	m_firstFree=offset+1;
	}
	else
	{
	int index=at>>>m_SHIFT;
	int maxindex=m_firstFree>>>m_SHIFT; // %REVIEW% (m_firstFree+1?)
	++m_firstFree;
	int offset=at&m_MASK;
	int push;

	// ***** Easier to work down from top?
	while(index<=maxindex)
	{
	int copylen=m_blocksize-offset-1;
	int[] block=m_map[index];
	if(null==block)
	{
	push=0;
	block=m_map[index]=new int[m_blocksize];
	}
	else
	{
	push=block[m_blocksize-1];
	System.arraycopy(block, offset , block, offset+1, copylen);
	}
	block[offset]=value;
	value=push;
	offset=0;
	++index;
	}
	}
	}

	/**
	* Wipe it out. Currently defined as equivalent to setSize(0).
	*/
	public void removeAllElements()
	{
	m_firstFree = 0;
	}

	/**
	* Removes the first occurrence of the argument from this vector.
	* If the object is found in this vector, each component in the vector
	* with an index greater or equal to the object's index is shifted
	* downward to have an index one smaller than the value it had
	* previously.
	*
	* @param s Int to remove from array
	*
	* @return True if the int was removed, false if it was not found
	*/
	private boolean removeElement(int s)
	{
	int at=indexOf(s,0);
	if(at<0)
	return false;
	removeElementAt(at);
	return true;
	}

	/**
	* Deletes the component at the specified index. Each component in
	* this vector with an index greater or equal to the specified
	* index is shifted downward to have an index one smaller than
	* the value it had previously.
	*
	* @param i index of where to remove and int
	*/
	private void removeElementAt(int at)
	{
	// No point in removing elements that "don't exist"...
	if(at<m_firstFree)
	{
	int index=at>>>m_SHIFT;
	int maxindex=m_firstFree>>>m_SHIFT;
	int offset=at&m_MASK;

	while(index<=maxindex)
	{
	int copylen=m_blocksize-offset-1;
	int[] block=m_map[index];
	if(null==block)
	block=m_map[index]=new int[m_blocksize];
	else
	System.arraycopy(block, offset+1, block, offset, copylen);
	if(index<maxindex)
	{
	int[] next=m_map[index+1];
	if(next!=null)
	block[m_blocksize-1]=(next!=null) ? next[0] : 0;
	}
	else
	block[m_blocksize-1]=0;
	offset=0;
	++index;
	}
	}
	--m_firstFree;
	}

	/**
	* Sets the component at the specified index of this vector to be the
	* specified object. The previous component at that position is discarded.
	*
	* The index must be a value greater than or equal to 0 and less
	* than the current size of the vector.
	*
	* @param node object to set
	* @param index Index of where to set the object
	*/
	public void setElementAt(int value, int at)
	{
	if(at<m_blocksize)
	m_map0[at]=value;
	else
	{
	int index=at>>>m_SHIFT;
	int offset=at&m_MASK;

	if(index>=m_map.length)
	{
	int newsize=index+m_numblocks;
	int[][] newMap=new int[newsize][];
	System.arraycopy(m_map, 0, newMap, 0, m_map.length);
	m_map=newMap;
	}

	int[] block=m_map[index];
	if(null==block)
	block=m_map[index]=new int[m_blocksize];
	block[offset]=value;
	}

	if(at>=m_firstFree)
	m_firstFree=at+1;
	}


	/**
	* Get the nth element. This is often at the innermost loop of an
	* application, so performance is critical.
	*
	* @param i index of value to get
	*
	* @return value at given index. If that value wasn't previously set,
	* the result is undefined for performance reasons. It may throw an
	* exception (see below), may return zero, or (if setSize has previously
	* been used) may return stale data.
	*
	* @throw ArrayIndexOutOfBoundsException if the index was _clearly_
	* unreasonable (negative, or past the highest block).
	*
	* @throw NullPointerException if the index points to a block that could
	* have existed (based on the highest index used) but has never had anything
	* set into it.
	* %REVIEW% Could add a catch to create the block in that case, or return 0.
	* Try/Catch is _supposed_ to be nearly free when not thrown to. Do we
	* believe that? Should we have a separate safeElementAt?
	*/
	public int elementAt(int i)
	{
	// This is actually a significant optimization!
	if(i<m_blocksize)
	return m_map0[i];

	return m_map[i>>>m_SHIFT][i&m_MASK];
	}

	/**
	* Tell if the table contains the given node.
	*
	* @param s object to look for
	*
	* @return true if the object is in the list
	*/
	private boolean contains(int s)
	{
	return (indexOf(s,0) >= 0);
	}

	/**
	* Searches for the first occurence of the given argument,
	* beginning the search at index, and testing for equality
	* using the equals method.
	*
	* @param elem object to look for
	* @param index Index of where to begin search
	* @return the index of the first occurrence of the object
	* argument in this vector at position index or later in the
	* vector; returns -1 if the object is not found.
	*/
	public int indexOf(int elem, int index)
	{
	if(index>=m_firstFree)
	return -1;

	int bindex=index>>>m_SHIFT;
	int boffset=index&m_MASK;
	int maxindex=m_firstFree>>>m_SHIFT;
	int[] block;

	for(;bindex<maxindex;++bindex)
	{
	block=m_map[bindex];
	if(block!=null)
	for(int offset=boffset;offset<m_blocksize;++offset)
	if(block[offset]==elem)
	return offset+bindex*m_blocksize;
	boffset=0; // after first
	}
	// Last block may need to stop before end
	int maxoffset=m_firstFree&m_MASK;
	block=m_map[maxindex];
	for(int offset=boffset;offset<maxoffset;++offset)
	if(block[offset]==elem)
	return offset+maxindex*m_blocksize;

	return -1;
	}

	/**
	* Searches for the first occurence of the given argument,
	* beginning the search at index, and testing for equality
	* using the equals method.
	*
	* @param elem object to look for
	* @return the index of the first occurrence of the object
	* argument in this vector at position index or later in the
	* vector; returns -1 if the object is not found.
	*/
	public int indexOf(int elem)
	{
	return indexOf(elem,0);
	}

	/**
	* Searches for the first occurence of the given argument,
	* beginning the search at index, and testing for equality
	* using the equals method.
	*
	* @param elem Object to look for
	* @return the index of the first occurrence of the object
	* argument in this vector at position index or later in the
	* vector; returns -1 if the object is not found.
	*/
	private int lastIndexOf(int elem)
	{
	int boffset=m_firstFree&m_MASK;
	for(int index=m_firstFree>>>m_SHIFT;
	index>=0;
	--index)
	{
	int[] block=m_map[index];
	if(block!=null)
	for(int offset=boffset; offset>=0; --offset)
	if(block[offset]==elem)
	return offset+index*m_blocksize;
	boffset=0; // after first
	}
	return -1;
	}

	}