K - The map key type.V - The map value type.public class TransactionalMap<K,V> extends SemiPersistent<TransactionalMap<K,V>> implements OpaqueMap<K,V>
| Constructor and Description |
|---|
TransactionalMap()
Constructs a new empty
TransactionalMap. |
TransactionalMap(Map<K,V> sourceMap)
Constructs new
TransactionalMap initializing it with the given collection. |
| Modifier and Type | Method and Description |
|---|---|
TransactionalMap<K,V> |
cleanCopy()
Creates a new transactional entity from the current one discarding all the local changes.
|
void |
clear()
Removes all of the mappings from this map (optional operation).
|
TransactionalMap<K,V> |
commit(TransactionalMap<K,V> globalState) |
boolean |
containsKey(K key)
Returns true if this map contains a mapping for the specified key.
|
protected TransactionalMap<K,V> |
dirtyCopy()
Copies references to the source data along with local changes and read/write logs.
|
V |
get(K key)
Returns the value to which the specified key is mapped, or
null if this map contains no mapping for the
key. |
boolean |
isEmpty()
Returns true if this map contains no key-value mappings.
|
Set<K> |
keySet()
Returns a
Set view of the keys contained in this map. |
V |
put(K key,
V value)
Associates the specified value with the specified key in this map (optional operation).
|
void |
putAll(Map<? extends K,? extends V> m)
Copies all of the mappings from the specified map to this map (optional operation).
|
V |
remove(K key)
Removes the mapping for a key from this map if it is present (optional operation).
|
int |
size()
Returns the number of key-value mappings in this map.
|
protected void |
update(TransactionalMap<K,V> changes,
boolean onlyReadLogs)
Updates local changes and change logs using change logs of the arguments.
|
public TransactionalMap()
TransactionalMap.public TransactionalMap(Map<K,V> sourceMap)
TransactionalMap initializing it with the given collection. Passed collection is copied.sourceMap - The TransactionalMap initial state.public int size()
OpaqueMapTo preserve transactional consistency this operation marks the entire universe of keys as accessed, this means that commits to an updated global state will be rejected.
public boolean isEmpty()
OpaqueMap
To preserve transactional consistency this operation marks the entire universe of keys as accessed in cases when
map is empty but was not cleared with call clear() method, this means that commits to an updated
global state will be rejected.
public void clear()
OpaqueMappublic boolean containsKey(K key)
OpaqueMapcontainsKey in interface OpaqueMap<K,V>key - key whose presence in this map is to be testedpublic V get(K key)
OpaqueMapnull if this map contains no mapping for the
key.
More formally, if this map contains a mapping from a key k to a value v such that
(key==null ? k==null : key.equals(k)), then this method returns v; otherwise it returns
null. (There can be at most one such mapping.)
If this map permits null values, then a return value of null does not necessarily indicate that
the map contains no mapping for the key; it's also possible that the map explicitly maps the key to null.
The containsKey operation may be used to distinguish these two cases.
public V put(K key, V value)
OpaqueMapm.containsKey(k) would return
true.)put in interface OpaqueMap<K,V>key - key with which the specified value is to be associatedvalue - value to be associated with the specified keypublic void putAll(Map<? extends K,? extends V> m)
OpaqueMapput(k, v) on this map once for each mapping from key
k to value v in the specified map. The behavior of this operation is undefined if the specified
map is modified while the operation is in progress.public V remove(K key)
OpaqueMap(key==null ? k==null : key.equals(k)), that mapping is removed. (The map can contain at most one
such mapping.)
Returns the value to which this map previously associated the key, or null if the map contained no mapping for the key.
If this map permits null values, then a return value of null does not necessarily indicate that the map contained no mapping for the key; it's also possible that the map explicitly mapped the key to null.
The map will not contain a mapping for the specified key once the call returns.
public Set<K> keySet()
OpaqueMapSet view of the keys contained in this map. The set is backed by the map, so changes to the map
are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress
(except through the iterator's own remove operation), the results of the iteration are undefined. The
set supports element removal, which removes the corresponding mapping from the map, via the
Iterator.remove, Set.remove, removeAll, retainAll, and clear
operations. It does not support the add or addAll operations.
In cases when the map hasn't been cleared within the running transaction it is highly probable that any interaction with the resulting set will mark the entire universe of keys as accessed, this means that commits to an updated global state will be rejected. Following actions are highly advised to be done in read-only transactions:
public TransactionalMap<K,V> cleanCopy()
SemiPersistentcleanCopy in class SemiPersistent<TransactionalMap<K,V>>protected TransactionalMap<K,V> dirtyCopy()
SemiPersistentSemiPersistent#update(Object) will not work.dirtyCopy in class SemiPersistent<TransactionalMap<K,V>>protected void update(TransactionalMap<K,V> changes, boolean onlyReadLogs)
SemiPersistentSemiPersistent.dirtyCopy(). update in class SemiPersistent<TransactionalMap<K,V>>changes - The branched collection possibly with updates.onlyReadLogs - If true only read logs are updated. Useful for read-only transactions.public TransactionalMap<K,V> commit(TransactionalMap<K,V> globalState)
Copyright © 2013 CERN, The European Organization for Nuclear Research. All Rights Reserved.