com.hazelcast.map.impl.recordstore

Class StorageImpl<R extends Record>

java.lang.Object

com.hazelcast.map.impl.recordstore.StorageImpl<R>

Type Parameters:

R - the value type to be put in this storage.

All Implemented Interfaces:

Storage<Data,R>

public class StorageImpl<R extends Record>
extends Object
implements Storage<Data,R>

Default implementation of Storage layer used by a RecordStore

Method Summary

Modifier and Type	Method and Description
void	clear(boolean isDuringShutdown)
boolean	containsKey(Data key)
void	destroy(boolean isDuringShutdown)
void	disposeDeferredBlocks()
MapEntriesWithCursor	fetchEntries(int tableIndex, int size, SerializationService serializationService) Fetch minimally size items from the tableIndex position.
MapKeysWithCursor	fetchKeys(int tableIndex, int size) Fetch minimally size keys from the tableIndex position.
R	get(Data key)
EntryCostEstimator	getEntryCostEstimator()
R	getIfSameKey(Data key) Gives the same result as Storage.get(Object), but with the additional constraint that the supplied key must not just be equal to, but be exactly the same key blob (at the same memory address) as the one stored.
Iterable<LazyEntryViewFromRecord>	getRandomSamples(int sampleCount) Used for sampling based eviction, returns sampled entries.
boolean	isEmpty()
Iterator<R>	mutationTolerantIterator() Returned iterator from this method doesn't throw ConcurrentModificationException to fail fast.
void	put(Data key, R record)
void	removeRecord(R record)
void	setEntryCostEstimator(EntryCostEstimator entryCostEstimator)
int	size()
protected void	updateCostEstimate(long entrySize)
void	updateRecordValue(Data key, R record, Object value)
Collection<R>	values()

Methods inherited from class java.lang.Object

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

Method Detail

clear

public void clear(boolean isDuringShutdown)

Specified by:

clear in interface Storage<Data,R extends Record>

values

public Collection<R> values()

Specified by:

values in interface Storage<Data,R extends Record>

mutationTolerantIterator

public Iterator<R> mutationTolerantIterator()

Description copied from interface: Storage

Returned iterator from this method doesn't throw ConcurrentModificationException to fail fast. Because fail fast may not be the desired behaviour always. For example if you are caching an iterator as in AbstractEvictableRecordStore.expirationIterator and you know that in next rounds you will eventually visit all entries, you don't need fail fast behaviour. Note that returned iterator is not thread-safe !!!

Specified by:

mutationTolerantIterator in interface Storage<Data,R extends Record>

Returns:

new iterator instance

put

public void put(Data key,
                R record)

Specified by:

put in interface Storage<Data,R extends Record>

updateRecordValue

public void updateRecordValue(Data key,
                              R record,
                              Object value)

Specified by:

updateRecordValue in interface Storage<Data,R extends Record>

get

public R get(Data key)

Specified by:

get in interface Storage<Data,R extends Record>

getIfSameKey

public R getIfSameKey(Data key)

Description copied from interface: Storage

Gives the same result as Storage.get(Object), but with the additional constraint that the supplied key must not just be equal to, but be exactly the same key blob (at the same memory address) as the one stored. The implementation of this method is only needed for the HD memory-based implementations.

Specified by:

getIfSameKey in interface Storage<Data,R extends Record>

size

public int size()

Specified by:

size in interface Storage<Data,R extends Record>

isEmpty

public boolean isEmpty()

Specified by:

isEmpty in interface Storage<Data,R extends Record>

destroy

public void destroy(boolean isDuringShutdown)

Specified by:

destroy in interface Storage<Data,R extends Record>

getEntryCostEstimator

public EntryCostEstimator getEntryCostEstimator()

Specified by:

getEntryCostEstimator in interface Storage<Data,R extends Record>

containsKey

public boolean containsKey(Data key)

Specified by:

containsKey in interface Storage<Data,R extends Record>

removeRecord

public void removeRecord(R record)

Specified by:

removeRecord in interface Storage<Data,R extends Record>

updateCostEstimate

protected void updateCostEstimate(long entrySize)

setEntryCostEstimator

public void setEntryCostEstimator(EntryCostEstimator entryCostEstimator)

Specified by:

setEntryCostEstimator in interface Storage<Data,R extends Record>

disposeDeferredBlocks

public void disposeDeferredBlocks()

Specified by:

disposeDeferredBlocks in interface Storage<Data,R extends Record>

getRandomSamples

public Iterable<LazyEntryViewFromRecord> getRandomSamples(int sampleCount)

Description copied from interface: Storage

Used for sampling based eviction, returns sampled entries.

Specified by:

getRandomSamples in interface Storage<Data,R extends Record>

Parameters:

sampleCount - sample count.

Returns:

sampled entries.

fetchKeys

public MapKeysWithCursor fetchKeys(int tableIndex,
                                   int size)

Description copied from interface: Storage

Fetch minimally size keys from the tableIndex position. The key is fetched on-heap.

NOTE: The implementation is free to return more than size items. This can happen if we cannot easily resume from the last returned item by receiving the tableIndex of the last item. The index can represent a bucket with multiple items and in this case the returned object will contain all items in that bucket, regardless if we exceed the requested size.

Specified by:

fetchKeys in interface Storage<Data,R extends Record>

Parameters:

tableIndex - the index (position) from which to resume

size - the minimal count of returned items

Returns:

fetched keys and the table index for keys AFTER the last returned key

fetchEntries

public MapEntriesWithCursor fetchEntries(int tableIndex,
                                         int size,
                                         SerializationService serializationService)

Description copied from interface: Storage

Fetch minimally size items from the tableIndex position. Both the key and value are fetched on-heap.

NOTE: The implementation is free to return more than size items. This can happen if we cannot easily resume from the last returned item by receiving the tableIndex of the last item. The index can represent a bucket with multiple items and in this case the returned object will contain all items in that bucket, regardless if we exceed the requested size.

Specified by:

fetchEntries in interface Storage<Data,R extends Record>

Parameters:

tableIndex - the index (position) from which to resume

size - the minimal count of returned items

Returns:

fetched entries and the table index for entries AFTER the last returned entry