com.sleepycat.je.rep.utilint

Class SizeAwaitMap<K,V>

java.lang.Object

com.sleepycat.je.rep.utilint.SizeAwaitMap<K,V>

All Implemented Interfaces:

Map<K,V>

public class SizeAwaitMap<K,V>
extends Object
implements Map<K,V>

Creates a Map that Threads can conveniently wait on to contain a specific number of entries, where the values optionally match a predicate. The wait functionality is provided by the sizeAwait() method defined by this class. Map values must not be null.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	SizeAwaitMap.Predicate<V> Specifies which values should be counted.

Nested classes/interfaces inherited from interface java.util.Map

Map.Entry<K,V>

Constructor Summary

Constructors

Constructor and Description
SizeAwaitMap(EnvironmentImpl envImpl, SizeAwaitMap.Predicate<V> predicate) Creates an instance of this class.

Method Summary

Modifier and Type	Method and Description
void	clear() Deprecated. Use clear(Exception) instead.
void	clear(Exception cause) Clears the underlying map and the latch map, after first counting them down, thus permitting any waiting threads to make progress.
boolean	containsKey(Object key)
boolean	containsValue(Object value)
Set<Map.Entry<K,V>>	entrySet() The caller should synchronize on the map while accessing the return value.
V	get(Object key)
StatGroup	getStatistics()
boolean	isEmpty()
Set<K>	keySet() The caller should synchronize on the map while accessing the return value.
V	put(K key, V value) Notes the addition of a new value and counts down any latches that were assigned to that threshold.
void	putAll(Map<? extends K,? extends V> t)
V	remove(Object key)
int	size()
boolean	sizeAwait(int thresholdSize, long timeout, TimeUnit unit) Causes the requesting thread to wait until the map reaches the specified size or the thread is interrupted.
Collection<V>	values() The caller should synchronize on the map while accessing the return value.

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.util.Map

compute, computeIfAbsent, computeIfPresent, equals, forEach, getOrDefault, hashCode, merge, putIfAbsent, remove, replace, replace, replaceAll

Constructor Detail

SizeAwaitMap

public SizeAwaitMap(EnvironmentImpl envImpl,
                    SizeAwaitMap.Predicate<V> predicate)

Creates an instance of this class.

Parameters:

envImpl - the environment, used for exception handling

predicate - the predicate for counting matching entries, or null to match all entries

Method Detail

getStatistics

public StatGroup getStatistics()

sizeAwait

public boolean sizeAwait(int thresholdSize,
                         long timeout,
                         TimeUnit unit)
                  throws InterruptedException

Causes the requesting thread to wait until the map reaches the specified size or the thread is interrupted.

Parameters:

thresholdSize - the size to wait for.

Returns:

true if the threshold was reached, false, if the wait timed out.

Throws:

InterruptedException - for the usual reasons, or if the map was cleared and the size threshold was not actually reached.

put

public V put(K key,
             V value)

Notes the addition of a new value and counts down any latches that were assigned to that threshold.

Specified by:

put in interface Map<K,V>

remove

public V remove(Object key)

Specified by:

remove in interface Map<K,V>

clear

@Deprecated
public void clear()
                       throws UnsupportedOperationException

Deprecated. Use clear(Exception) instead.

Specified by:

clear in interface Map<K,V>

Throws:

UnsupportedOperationException

clear

public void clear(Exception cause)

Clears the underlying map and the latch map, after first counting them down, thus permitting any waiting threads to make progress.

Parameters:

cause - the value is non-null if the map is being cleared in response to an exception and results in the exception being thrown in the waiting threads. It's null if the map is being cleared as part of a normal shutdown, in which case no exception is thrown.

containsKey

public boolean containsKey(Object key)

Specified by:

containsKey in interface Map<K,V>

containsValue

public boolean containsValue(Object value)

Specified by:

containsValue in interface Map<K,V>

entrySet

public Set<Map.Entry<K,V>> entrySet()

The caller should synchronize on the map while accessing the return value.

Specified by:

entrySet in interface Map<K,V>

get

public V get(Object key)

Specified by:

get in interface Map<K,V>

isEmpty

public boolean isEmpty()

Specified by:

isEmpty in interface Map<K,V>

keySet

public Set<K> keySet()

The caller should synchronize on the map while accessing the return value.

Specified by:

keySet in interface Map<K,V>

putAll

public void putAll(Map<? extends K,? extends V> t)

Specified by:

putAll in interface Map<K,V>

size

public int size()

Specified by:

size in interface Map<K,V>

values

public Collection<V> values()

The caller should synchronize on the map while accessing the return value.

Specified by:

values in interface Map<K,V>