org.apache.commons.collections4.map.AbstractIterableMap<K,V>
org.apache.commons.collections4.map.AbstractMapDecorator<K,V>
org.apache.commons.collections4.map.PassiveExpiringMap<K,V>
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Object
K - the type of the keys in the mapV - the type of the values in the mappublic class PassiveExpiringMap<K,V>
Decorates a Map to evict expired entries once their expiration
time has been reached.
When putting a key-value pair in the map this decorator uses a
PassiveExpiringMap.ConstantTimeToLiveExpirationPolicy to determine how long the entry should remain alive
as defined by an expiration time value.
When accessing the mapped value for a key, its expiration time is checked,
and if it is a negative value or if it is greater than the current time, the
mapped value is returned. Otherwise, the key is removed from the decorated
map, and null is returned.
When invoking methods that involve accessing the entire map contents (i.e
containsKey(Object), entrySet(), etc.) this decorator
removes all expired entries prior to actually completing the invocation.
Note that PassiveExpiringMap is not synchronized and is not
thread-safe. If you wish to use this map from multiple threads
concurrently, you must use appropriate synchronization. The simplest approach
is to wrap this map using Collections.synchronizedMap(Map).
This class may throw exceptions when accessed by concurrent threads without
synchronization.
| Nested Class Summary | |
|---|---|
static class |
PassiveExpiringMap.ConstantTimeToLiveExpirationPolicy<K,V>
A ExpirationPolicy
that returns a expiration time that is a
constant about of time in the future from the current time. |
static interface |
PassiveExpiringMap.ExpirationPolicy<K,V>
A policy to determine the expiration time for key-value entries. |
| Nested classes/interfaces inherited from interface java.util.Map |
|---|
Map.Entry<K,V> |
| Constructor Summary | |
|---|---|
PassiveExpiringMap()
Default constructor. |
|
PassiveExpiringMap(long timeToLiveMillis)
Construct a map decorator that decorates the given map using the given time-to-live value measured in milliseconds to create and use a PassiveExpiringMap.ConstantTimeToLiveExpirationPolicy expiration policy. |
|
PassiveExpiringMap(long timeToLiveMillis,
Map<K,V> map)
Construct a map decorator using the given time-to-live value measured in milliseconds to create and use a PassiveExpiringMap.ConstantTimeToLiveExpirationPolicy expiration policy. |
|
PassiveExpiringMap(long timeToLive,
TimeUnit timeUnit)
Construct a map decorator using the given time-to-live value measured in the given time units of measure to create and use a PassiveExpiringMap.ConstantTimeToLiveExpirationPolicy expiration policy. |
|
PassiveExpiringMap(long timeToLive,
TimeUnit timeUnit,
Map<K,V> map)
Construct a map decorator that decorates the given map using the given time-to-live value measured in the given time units of measure to create PassiveExpiringMap.ConstantTimeToLiveExpirationPolicy expiration policy. |
|
PassiveExpiringMap(Map<K,V> map)
Constructs a map decorator that decorates the given map and results in entries NEVER expiring. |
|
PassiveExpiringMap(PassiveExpiringMap.ExpirationPolicy<K,V> expiringPolicy)
Construct a map decorator using the given expiration policy to determine expiration times. |
|
PassiveExpiringMap(PassiveExpiringMap.ExpirationPolicy<K,V> expiringPolicy,
Map<K,V> map)
Construct a map decorator that decorates the given map and uses the given expiration policy to determine expiration times. |
|
| Method Summary | |
|---|---|
void |
clear()
Normal Map.clear() behavior with the addition of clearing all
expiration entries as well. |
boolean |
containsKey(Object key)
All expired entries are removed from the map prior to determining the contains result. |
boolean |
containsValue(Object value)
All expired entries are removed from the map prior to determining the contains result. |
Set<Map.Entry<K,V>> |
entrySet()
All expired entries are removed from the map prior to returning the entry set. |
V |
get(Object key)
All expired entries are removed from the map prior to returning the entry value. |
boolean |
isEmpty()
All expired entries are removed from the map prior to determining if it is empty. |
Set<K> |
keySet()
All expired entries are removed from the map prior to returning the key set. |
V |
put(K key,
V value)
Note that the return type is Object, rather than V as in the Map interface. |
void |
putAll(Map<? extends K,? extends V> mapToCopy)
|
V |
remove(Object key)
Normal Map.remove(Object) behavior with the addition of removing
any expiration entry as well. |
int |
size()
All expired entries are removed from the map prior to returning the size. |
Collection<V> |
values()
All expired entries are removed from the map prior to returning the value collection. |
| Methods inherited from class org.apache.commons.collections4.map.AbstractMapDecorator |
|---|
decorated, equals, hashCode, toString |
| Methods inherited from class org.apache.commons.collections4.map.AbstractIterableMap |
|---|
mapIterator |
| Methods inherited from class java.lang.Object |
|---|
clone, finalize, getClass, notify, notifyAll, wait, wait, wait |
| Constructor Detail |
|---|
public PassiveExpiringMap()
public PassiveExpiringMap(PassiveExpiringMap.ExpirationPolicy<K,V> expiringPolicy)
expiringPolicy - the policy used to determine expiration times of
entries as they are added.
public PassiveExpiringMap(PassiveExpiringMap.ExpirationPolicy<K,V> expiringPolicy,
Map<K,V> map)
expiringPolicy - the policy used to determine expiration times of
entries as they are added.map - the map to decorate, must not be null.
IllegalArgumentException - if the map is null.public PassiveExpiringMap(long timeToLiveMillis)
PassiveExpiringMap.ConstantTimeToLiveExpirationPolicy expiration policy.
timeToLiveMillis - the constant amount of time (in milliseconds) an
entry is available before it expires. A negative value results in
entries that NEVER expire. A zero value results in entries that
ALWAYS expire.
public PassiveExpiringMap(long timeToLiveMillis,
Map<K,V> map)
PassiveExpiringMap.ConstantTimeToLiveExpirationPolicy expiration policy. If there
are any elements already in the map being decorated, they will NEVER
expire unless they are replaced.
timeToLiveMillis - the constant amount of time (in milliseconds) an
entry is available before it expires. A negative value results in
entries that NEVER expire. A zero value results in entries that
ALWAYS expire.map - the map to decorate, must not be null.
IllegalArgumentException - if the map is null.
public PassiveExpiringMap(long timeToLive,
TimeUnit timeUnit)
PassiveExpiringMap.ConstantTimeToLiveExpirationPolicy expiration policy.
timeToLive - the constant amount of time an entry is available
before it expires. A negative value results in entries that NEVER
expire. A zero value results in entries that ALWAYS expire.timeUnit - the unit of time for the timeToLive
parameter, must not be null.
IllegalArgumentException - if the time unit is null.
public PassiveExpiringMap(long timeToLive,
TimeUnit timeUnit,
Map<K,V> map)
PassiveExpiringMap.ConstantTimeToLiveExpirationPolicy expiration policy. This policy
is used to determine expiration times. If there are any elements already
in the map being decorated, they will NEVER expire unless they are
replaced.
timeToLive - the constant amount of time an entry is available
before it expires. A negative value results in entries that NEVER
expire. A zero value results in entries that ALWAYS expire.timeUnit - the unit of time for the timeToLive
parameter, must not be null.map - the map to decorate, must not be null.
IllegalArgumentException - if the time unit is null.
IllegalArgumentException - if the map is null.public PassiveExpiringMap(Map<K,V> map)
map - the map to decorate, must not be null.
IllegalArgumentException - if the map is null.| Method Detail |
|---|
public void clear()
Map.clear() behavior with the addition of clearing all
expiration entries as well.
clear in interface Map<K,V>clear in interface Put<K,V>clear in class AbstractMapDecorator<K,V>Map.clear()public boolean containsKey(Object key)
containsKey in interface Map<K,V>containsKey in interface Get<K,V>containsKey in class AbstractMapDecorator<K,V>Map.containsKey(Object)public boolean containsValue(Object value)
containsValue in interface Map<K,V>containsValue in interface Get<K,V>containsValue in class AbstractMapDecorator<K,V>Map.containsValue(Object)public Set<Map.Entry<K,V>> entrySet()
entrySet in interface Map<K,V>entrySet in interface Get<K,V>entrySet in class AbstractMapDecorator<K,V>Map.entrySet()public V get(Object key)
get in interface Map<K,V>get in interface Get<K,V>get in class AbstractMapDecorator<K,V>Map.get(Object)public boolean isEmpty()
isEmpty in interface Map<K,V>isEmpty in interface Get<K,V>isEmpty in class AbstractMapDecorator<K,V>Map.isEmpty()public Set<K> keySet()
keySet in interface Map<K,V>keySet in interface Get<K,V>keySet in class AbstractMapDecorator<K,V>Map.keySet()
public V put(K key,
V value)
Put
put in interface Map<K,V>put in interface Put<K,V>put in class AbstractMapDecorator<K,V>Map.put(Object, Object)public void putAll(Map<? extends K,? extends V> mapToCopy)
putAll in interface Map<K,V>putAll in interface Put<K,V>putAll in class AbstractMapDecorator<K,V>Map.putAll(Map)public V remove(Object key)
Map.remove(Object) behavior with the addition of removing
any expiration entry as well.
remove in interface Map<K,V>remove in interface Get<K,V>remove in class AbstractMapDecorator<K,V>Map.remove(Object)public int size()
size in interface Map<K,V>size in interface Get<K,V>size in class AbstractMapDecorator<K,V>Map.size()public Collection<V> values()
values in interface Map<K,V>values in interface Get<K,V>values in class AbstractMapDecorator<K,V>Map.values()
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||