K
- key typeV
- value typepublic class ClientReplicatedMapProxy<K,V> extends ClientProxy implements ReplicatedMap<K,V>
Constructor and Description |
---|
ClientReplicatedMapProxy(String serviceName,
String objectName) |
Modifier and Type | Method and Description |
---|---|
String |
addEntryListener(EntryListener<K,V> listener)
Adds an entry listener for this map.
|
String |
addEntryListener(EntryListener<K,V> listener,
K key)
Adds the specified entry listener for the specified key.
|
String |
addEntryListener(EntryListener<K,V> listener,
Predicate<K,V> predicate)
Adds an continuous entry listener for this map.
|
String |
addEntryListener(EntryListener<K,V> listener,
Predicate<K,V> predicate,
K key)
Adds an continuous entry listener for this map.
|
void |
clear()
The clear operation is used for wiping data out of the replicated maps.
|
boolean |
containsKey(Object key) |
boolean |
containsValue(Object value) |
Set<Map.Entry<K,V>> |
entrySet()
Returns a lazy
Set view of the mappings contained in this map.A LazySet is optimized for querying speed (preventing eager deserialization and hashing on HashSet insertion) and does NOT provide all operations. |
V |
get(Object key) |
boolean |
isEmpty() |
Set<K> |
keySet()
Returns a lazy
Set view of the key contained in this map.A LazySet is optimized for querying speed (preventing eager deserialization and hashing on HashSet insertion) and does NOT provide all operations. |
protected void |
onDestroy()
Called before proxy is destroyed.
|
V |
put(K key,
V value) |
V |
put(K key,
V value,
long ttl,
TimeUnit timeUnit)
Associates a given value to the specified key and replicates it to the
cluster.
|
void |
putAll(Map<? extends K,? extends V> m) |
V |
remove(Object key) |
boolean |
removeEntryListener(String id)
Removes the specified entry listener.
|
int |
size() |
String |
toString() |
Collection<V> |
values()
Returns a lazy
Collection view of the values contained in this map.A LazyCollection is optimized for querying speed (preventing eager deserialization and hashing on HashSet insertion) and does NOT provide all operations. |
Collection<V> |
values(Comparator<V> comparator)
Returns a eagerly populated
Collection view of the values contained
in this map.The collection is NOT backed by the map, so changes to the map are NOT reflected in the collection, and vice-versa. The order of the elements is guaranteed by executing the given Comparator before returning the elements.Changes to any returned object are NOT replicated back to other members. |
destroy, equals, getContext, getId, getName, getPartitionKey, getServiceName, hashCode, invoke, invoke, invoke, invokeInterruptibly, listen, listen, onInitialize, onShutdown, setContext, stopListening, throwExceptionIfNull, toData, toObject
clone, equals, finalize, getClass, notify, notifyAll, wait, wait, wait
destroy, getId, getName, getPartitionKey, getServiceName
protected void onDestroy()
ClientProxy
onDestroy
in class ClientProxy
public V put(K key, V value, long ttl, TimeUnit timeUnit)
ReplicatedMap
Associates a given value to the specified key and replicates it to the cluster. If there is an old value, it will be replaced by the specified one and returned from the call.
In addition, you have to specify a ttl and its TimeUnit
to define when the value is outdated and thus should be removed from the
replicated map.
put
in interface ReplicatedMap<K,V>
key
- key with which the specified value is to be associatedvalue
- value to be associated with the specified keyttl
- ttl to be associated with the specified key-value pairtimeUnit
- TimeUnit to be used for the ttl valuepublic boolean containsKey(Object key)
containsKey
in interface Map<K,V>
public boolean containsValue(Object value)
containsValue
in interface Map<K,V>
public void clear()
ReplicatedMap
The clear operation is used for wiping data out of the replicated maps. It is the only synchronous remote operation in this implementation, so be aware that this might be a slow operation.
If some node fails on executing the operation, it is retried for at most
3 times (on the failing nodes only). If not working after the third time, this
method throws a OperationTimeoutException
back
to the caller.
public boolean removeEntryListener(String id)
ReplicatedMap
removeEntryListener
in interface ReplicatedMap<K,V>
id
- id of the registered listenerpublic String addEntryListener(EntryListener<K,V> listener)
ReplicatedMap
addEntryListener
in interface ReplicatedMap<K,V>
listener
- entry listenerpublic String addEntryListener(EntryListener<K,V> listener, K key)
ReplicatedMap
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.addEntryListener
in interface ReplicatedMap<K,V>
listener
- the entry listenerkey
- the key to listen topublic String addEntryListener(EntryListener<K,V> listener, Predicate<K,V> predicate)
ReplicatedMap
addEntryListener
in interface ReplicatedMap<K,V>
listener
- the entry listenerpredicate
- the predicate for filtering entriespublic String addEntryListener(EntryListener<K,V> listener, Predicate<K,V> predicate, K key)
ReplicatedMap
addEntryListener
in interface ReplicatedMap<K,V>
listener
- the entry listenerpredicate
- the predicate for filtering entrieskey
- the key to listen topublic Set<K> keySet()
ReplicatedMap
Set
view of the key contained in this map.UnsupportedOperationException
. Same is true for operations
like Set.contains(Object)
and
Set.containsAll(java.util.Collection)
which would result in
very poor performance if called repeatedly (for example i a loop). If the use
case is different from querying the data please copy the resulting set into a
new HashSet
.
ReplicatedMap<K, V> repMap = ...; // Returns a LazySet Set<K> keySet = repMap.keySet(); Set<K> copy = new HashSet<K>(keySet); for (K key : possibleKeys) { if (!copy.contains(key)) return false; }Due to the lazy nature of the returned set so changes to the map (addition, removal, update) might be reflected in the set.
public Collection<V> values()
ReplicatedMap
Collection
view of the values contained in this map.UnsupportedOperationException
. Same is true for operations
like Collection.contains(Object)
and
Collection.containsAll(java.util.Collection)
would result in
very poor performance if called repeatedly (for example in a loop). If the use
case is different from querying the data please copy the resulting set into a
new List
or similar data structure.
ReplicatedMap<K, V> repMap = ...; // Returns a LazyCollection Collection<V> values = repMap.values(); List<V> copy = new ArrayList<V>(values); if (copy.containsAll(possibleValues)) { // ... }Due to the lazy nature of the returned set so changes to the map (addition, removal, update) might be reflected in the set.
ReplicatedMap.values(java.util.Comparator)
to force reordering of the
elements before returning.public Collection<V> values(Comparator<V> comparator)
ReplicatedMap
Collection
view of the values contained
in this map.Comparator
before returning the elements.values
in interface ReplicatedMap<K,V>
comparator
- the Comparator to sort the returned elementspublic Set<Map.Entry<K,V>> entrySet()
ReplicatedMap
Set
view of the mappings contained in this map.UnsupportedOperationException
. Same is true for operations
like Set.contains(Object)
and
Set.containsAll(java.util.Collection)
which would result in
very poor performance if called repeatedly (for example i a loop). If the use
case is different from querying the data please copy the resulting set into a
new HashSet
.
ReplicatedMap<K, V> repMap = ...; // Returns a LazySet Set<Map.Entry<K, V>> entrySet = repMap.entrySet(); Set<Map.Entry<K, V>> copy = new HashSet<Map.Entry<K, V>>(entrySet);Due to the lazy nature of the returned set so changes to the map (addition, removal, update) might be reflected in the set.
Copyright © 2016 Hazelcast, Inc.. All Rights Reserved.