gnu.trove.impl.hash.TPrimitiveHash Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of trove4j Show documentation
The Trove library provides high speed regular and primitive collections for Java.
The newest version!
///////////////////////////////////////////////////////////////////////////////
// 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 THash instance with the default
     * capacity and load factor.
     */
    public TPrimitiveHash() {
        super();
    }


    /**
     * Creates a new TPrimitiveHash instance with a prime
     * capacity at or near the specified capacity and with the default
     * load factor.
     *
     * @param initialCapacity an int value
     */
    public TPrimitiveHash( int initialCapacity ) {
        this( initialCapacity, DEFAULT_LOAD_FACTOR );
    }


    /**
     * Creates a new TPrimitiveHash instance with a prime
     * capacity at or near the minimum needed to hold
     * initialCapacity elements with load factor
     * loadFactor without triggering a rehash.
     *
     * @param initialCapacity an int value
     * @param loadFactor      a float 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 index.
     *
     * @param index an int value
     */
    protected void removeAt( int index ) {
        _states[index] = REMOVED;
        super.removeAt( index );
    }


    /**
     * initializes the hashtable to a prime capacity which is at least
     * initialCapacity + 1.
     *
     * @param initialCapacity an int value
     * @return the actual capacity chosen
     */
    protected int setUp( int initialCapacity ) {
        int capacity;

        capacity = super.setUp( initialCapacity );
        _states = new byte[capacity];
        return capacity;
    }
} // TPrimitiveHash