org.cache2k.impl

Class Hash<E extends Entry>

java.lang.Object

org.cache2k.impl.Hash<E>

public class Hash<E extends Entry>
extends Object

Fast hash table implementation. Why we don't want to use the Java HashMap implementation: We need to move the entries back and forth between different hashes. If we do this, each time an entry object needs to be allocated and deallocated. Second, we need to do countermeasures, if a key changes its value and hashcode during its use in the cache. Although it is a user error and therefore not our primary concern, the effects can be very curious and hard to find. Third, we want to have use the hash partly unsynchronized, so we should know the implementation details. Fourth, we can leave out "details" of a general hash table, like shrinking. Our hash table only expands. Access needs to be public, since we want to access the hash primitives from classes in another package.

Field Summary

Fields

Modifier and Type	Field and Description
int	maxFill
int	size

Constructor Summary

Constructors

Constructor and Description
Hash()

Method Summary

Methods

Modifier and Type	Method and Description
static int	calcEntryCount(Entry[] _hashTable) Count the entries in the hash table, by scanning through the hash table.
static void	calcHashCollisionInfo(org.cache2k.impl.BaseCache.CollisionInfo inf, Entry[] _hashTable)
void	cleared() The cache with this hash was cleared and the hash table is no longer in used.
void	close() Cache was closed.
static boolean	contains(Entry[] _hashTable, Object key, int _hashCode)
void	decrementSuppressExpandCount()
void	incrementSuppressExpandCount() Usage/reference counter for iterations to suspend expand until the iteration finished.
static int	index(Entry[] _hashTable, int _hashCode)
E[]	init(Class<E> _entryType)
E[]	insert(E[] _hashTable, Entry _entry)
static void	insertWoExpand(Entry[] _hashTable, Entry e)
boolean	isCleared() Operations should terminate
boolean	isClosed() Operations should terminate and throw a CacheClosedException
static <E extends Entry> E	lookup(E[] _hashTable, Object key, int _hashCode)
E	remove(E[] _hashTable, Object key, int hc) Remove entry from the hash.
boolean	remove(Entry[] _hashTable, Entry _entry)
boolean	shouldAbort()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

size

public int size

maxFill

public int maxFill

Constructor Detail

Hash

public Hash()

Method Detail

index

public static int index(Entry[] _hashTable,
        int _hashCode)

lookup

public static <E extends Entry> E lookup(E[] _hashTable,
                         Object key,
                         int _hashCode)

contains

public static boolean contains(Entry[] _hashTable,
               Object key,
               int _hashCode)

insertWoExpand

public static void insertWoExpand(Entry[] _hashTable,
                  Entry e)

calcHashCollisionInfo

public static void calcHashCollisionInfo(org.cache2k.impl.BaseCache.CollisionInfo inf,
                         Entry[] _hashTable)

calcEntryCount

public static int calcEntryCount(Entry[] _hashTable)

Count the entries in the hash table, by scanning through the hash table. This is used for integrity checks.

remove

public boolean remove(Entry[] _hashTable,
             Entry _entry)

remove

public E remove(E[] _hashTable,
       Object key,
       int hc)

Remove entry from the hash. We never shrink the hash table, so the array keeps identical. After this remove operation the entry object may be inserted in another hash.

insert

public E[] insert(E[] _hashTable,
         Entry _entry)

incrementSuppressExpandCount

public void incrementSuppressExpandCount()

Usage/reference counter for iterations to suspend expand until the iteration finished. This is needed for correctness of the iteration, if an expand is done during the iteration process, the iterations returns duplicate entries or not all entries.

Failing to operate the increment/decrement in balance will mean that hash table expands are blocked forever, which is a serious error condition. Typical problems arise by thrown exceptions during an iteration.

decrementSuppressExpandCount

public void decrementSuppressExpandCount()

cleared

public void cleared()

The cache with this hash was cleared and the hash table is no longer in used. Signal to iterations to abort.

close

public void close()

Cache was closed. Inform operations/iterators on the hash.

isCleared

public boolean isCleared()

Operations should terminate

isClosed

public boolean isClosed()

Operations should terminate and throw a CacheClosedException

shouldAbort

public boolean shouldAbort()

init

public E[] init(Class<E> _entryType)