com.hazelcast.cache.impl

Class AbstractClusterWideIterator<K,V>

java.lang.Object

com.hazelcast.cache.impl.AbstractClusterWideIterator<K,V>

Type Parameters:

K - the type of key.

V - the type of value.

All Implemented Interfaces:

Iterator<javax.cache.Cache.Entry<K,V>>

Direct Known Subclasses:

ClientClusterWideIterator, ClusterWideIterator

public abstract class AbstractClusterWideIterator<K,V>
extends Object
implements Iterator<javax.cache.Cache.Entry<K,V>>

AbstractClusterWideIterator provides the core iterator functionality shared by its descendants.

Hazelcast cluster is made of partitions which holds a slice of all clusters data. Partition count never increase or decrease in a cluster. In order to implement an iterator over a partitioned data, we use the following parameters.

• To iterate over partitioned data, we use partitionId as the first parameter of this iterator.
• Each partition may have a lot of entries, so we use a second parameter to track the iteration of the partition.

Iteration steps:

• fetching fixed sized of keys from the current partition defined by partitionId.
• iteration on fetched keys.
• get value of each key with next() when method is called.
• when fetched keys are all used by calling next(), more keys are fetched from the cluster.

This implementation iterates over partitions and for each partition it iterates over the internal map using the internal table index of the map SampleableConcurrentHashMap.

Fetching data from cluster:

Fetching is getting a fixed size of keys from the internal table of records of a partition defined by partitionId. Table index is also provided as a table index locator. Fetch response is the keys and last table index. The last table index is included in the result to be used in the next fetch.

Notes:

• Iterator fetches keys in batch with a fixed size that is configurable.
• Fetched keys are cached in the iterator to be used in each iteration step.
• hasNext() may return true for a key already removed.
• hasNext() only return false when all known keys are fetched and iterated.
• next() may return null although cache never has null value. This may happen when, for example, someone removes the entry after the current thread has checked with hasNext().
• This implementation does not affected by value updates as each value is got from the cluster when next() called.

See Also:

AbstractCacheRecordStore.fetchKeys(int tableIndex, int size), ClusterWideIterator, CacheKeyIterationResult

Field Summary

Fields

Modifier and Type	Field and Description
protected ICacheInternal<K,V>	cache
protected int	currentIndex
protected static int	DEFAULT_FETCH_SIZE
protected int	fetchSize
protected int	index
protected int	lastTableIndex The table is segment table of hash map, which is an array that stores the actual records.
protected int	partitionCount
protected int	partitionIndex
protected boolean	prefetchValues
protected List	result

Constructor Summary

Constructors

Constructor and Description
AbstractClusterWideIterator(ICacheInternal<K,V> cache, int partitionCount, int fetchSize, boolean prefetchValues)

Method Summary

Modifier and Type	Method and Description
protected boolean	advance()
protected void	ensureOpen()
protected abstract List	fetch()
protected int	getPartitionCount()
boolean	hasNext()
javax.cache.Cache.Entry<K,V>	next()
void	remove()
protected void	setLastTableIndex(List response, int lastTableIndex)
protected abstract Data	toData(Object obj)
protected abstract <T> T	toObject(Object data)

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.util.Iterator

forEachRemaining

Field Detail

DEFAULT_FETCH_SIZE

protected static final int DEFAULT_FETCH_SIZE

See Also:

Constant Field Values

cache

protected ICacheInternal<K,V> cache

result

protected List result

partitionCount

protected final int partitionCount

partitionIndex

protected int partitionIndex

lastTableIndex

protected int lastTableIndex

The table is segment table of hash map, which is an array that stores the actual records. This field is used to mark where the latest entry is read.

The iteration will start from highest index available to the table. It will be converted to array size on the server side.

fetchSize

protected final int fetchSize

prefetchValues

protected boolean prefetchValues

index

protected int index

currentIndex

protected int currentIndex

Constructor Detail

AbstractClusterWideIterator

public AbstractClusterWideIterator(ICacheInternal<K,V> cache,
                                   int partitionCount,
                                   int fetchSize,
                                   boolean prefetchValues)

Method Detail

hasNext

public boolean hasNext()

Specified by:

hasNext in interface Iterator<javax.cache.Cache.Entry<K,V>>

next

public javax.cache.Cache.Entry<K,V> next()

Specified by:

next in interface Iterator<javax.cache.Cache.Entry<K,V>>

remove

public void remove()

Specified by:

remove in interface Iterator<javax.cache.Cache.Entry<K,V>>

advance

protected boolean advance()

ensureOpen

protected void ensureOpen()

setLastTableIndex

protected void setLastTableIndex(List response,
                                 int lastTableIndex)

getPartitionCount

protected int getPartitionCount()

fetch

protected abstract List fetch()

toData

protected abstract Data toData(Object obj)

toObject

protected abstract <T> T toObject(Object data)