///////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2001, Eric D. Friedman All Rights Reserved.
// Copyright (c) 2009, Rob Eden All Rights Reserved.
// Copyright (c) 2009, Jeff Randall All Rights Reserved.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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 Lesser General Public
// License along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
///////////////////////////////////////////////////////////////////////////////
package gnu.trove.impl.hash;
import gnu.trove.impl.HashFunctions;
/**
* The base class for hashtables of primitive values. Since there is
* no notion of object equality for primitives, it isn't possible to
* use a `REMOVED' object to track deletions in an open-addressed table.
* So, we have to resort to using a parallel `bookkeeping' array of bytes,
* in which flags can be set to indicate that a particular slot in the
* hash table is FREE, FULL, or REMOVED.
*
* @author Eric D. Friedman, Rob Eden, Jeff Randall
* @version $Id: TPrimitiveHash.java,v 1.1.2.6 2010/03/01 23:39:07 robeden Exp $
*/
abstract public class TPrimitiveHash extends THash {
@SuppressWarnings( { "UnusedDeclaration" } )
static final long serialVersionUID = 1L;
/**
* flags indicating whether each position in the hash is
* FREE, FULL, or REMOVED
*/
public transient byte[] _states;
/* constants used for state flags */
/** flag indicating that a slot in the hashtable is available */
public static final byte FREE = 0;
/** flag indicating that a slot in the hashtable is occupied */
public static final byte FULL = 1;
/**
* flag indicating that the value of a slot in the hashtable
* was deleted
*/
public static final byte REMOVED = 2;
/**
* Creates a new <code>THash</code> instance with the default
* capacity and load factor.
*/
public TPrimitiveHash() {
super();
}
/**
* Creates a new <code>TPrimitiveHash</code> instance with a prime
* capacity at or near the specified capacity and with the default
* load factor.
*
* @param initialCapacity an <code>int</code> value
*/
public TPrimitiveHash( int initialCapacity ) {
this( initialCapacity, DEFAULT_LOAD_FACTOR );
}
/**
* Creates a new <code>TPrimitiveHash</code> instance with a prime
* capacity at or near the minimum needed to hold
* <tt>initialCapacity<tt> elements with load factor
* <tt>loadFactor</tt> without triggering a rehash.
*
* @param initialCapacity an <code>int</code> value
* @param loadFactor a <code>float</code> value
*/
public TPrimitiveHash( int initialCapacity, float loadFactor ) {
super();
initialCapacity = Math.max( 1, initialCapacity );
_loadFactor = loadFactor;
setUp( HashFunctions.fastCeil( initialCapacity / loadFactor ) );
}
/**
* Returns the capacity of the hash table. This is the true
* physical capacity, without adjusting for the load factor.
*
* @return the physical capacity of the hash table.
*/
public int capacity() {
return _states.length;
}
/**
* Delete the record at <tt>index</tt>.
*
* @param index an <code>int</code> value
*/
protected void removeAt( int index ) {
_states[index] = REMOVED;
super.removeAt( index );
}
/**
* initializes the hashtable to a prime capacity which is at least
* <tt>initialCapacity + 1</tt>.
*
* @param initialCapacity an <code>int</code> value
* @return the actual capacity chosen
*/
protected int setUp( int initialCapacity ) {
int capacity;
capacity = super.setUp( initialCapacity );
_states = new byte[capacity];
return capacity;
}
} // TPrimitiveHash