@ThreadSafe
public interface Node<K,V>
named
logical grouping of data in the JBoss Cache
.
A node should be used to contain data for a single data record, for example
information about a particular person or account.
One purpose of grouping cache data into separate nodes is to minimize transaction
locking interference, and increase concurrency. So for example, when multiple threads or
possibly distributed caches are acccessing different accounts simultaneously.
Another is that when making changes to this node, its data might be kept in a single
database row or file on disk. (Persisted via the use of a CacheLoader
.)
A node has references to its children, parent (each node except the root - defined by Fqn.ROOT
- has
a single parent) and data contained within the node (as key/value pairs). The
data access methods are similar to the collections Map
interface,
but some are read-only or return copies of the underlying the data.
Cache
Modifier and Type | Method and Description |
---|---|
Node<K,V> |
addChild(Fqn f)
Adds a child node with the given
Fqn under the current node. |
void |
clearData()
Removes all mappings from the node's data map.
|
int |
dataSize() |
V |
get(K key)
Returns the value to which this node maps the specified key.
|
Node<K,V> |
getChild(Fqn f)
Returns the child node
|
Node<K,V> |
getChild(Object name) |
Set<Node<K,V>> |
getChildren()
Returns an immutable set of children nodes.
|
Set<Object> |
getChildrenNames()
Returns an immutable set of children node names.
|
Map<K,V> |
getData()
Returns a map containing the data in this
Node . |
Fqn |
getFqn()
|
Set<K> |
getKeys()
|
Node<K,V> |
getParent()
Returns the parent node.
|
boolean |
hasChild(Fqn f)
Returns true if the child node denoted by the relative
Fqn passed in exists. |
boolean |
hasChild(Object o)
Returns true if the child node denoted by the Object name passed in exists.
|
boolean |
isLeaf() |
boolean |
isLockForChildInsertRemove()
Tests whether this node is configured to be exclusively locked when inserting or removing children.
|
boolean |
isResident()
Nodes marked resident would be ignored by the eviction algorithms.
|
boolean |
isValid()
Tests if a node reference is still valid.
|
V |
put(K key,
V value)
Associates the specified value with the specified key for this node.
|
void |
putAll(Map<? extends K,? extends V> map)
Copies all of the mappings from the specified map to this node's map.
|
V |
putIfAbsent(K key,
V value)
If the specified key is not already associated with a value, associate it with the given value, and returns the
Object (if any) that occupied the space, or null.
|
void |
releaseObjectReferences(boolean recursive)
Method that releases object references of cached objects held in the cache by serializing them to byte buffers.
|
V |
remove(K key)
Removes the mapping for this key from this node if it is present.
|
boolean |
removeChild(Fqn f)
Removes a child node specified by the given relative
Fqn . |
boolean |
removeChild(Object childName)
Removes a child node specified by the given name.
|
V |
replace(K key,
V value)
Replace entry for key only if currently mapped to some value.
|
boolean |
replace(K key,
V oldValue,
V newValue)
Replace entry for key only if currently mapped to given value.
|
void |
replaceAll(Map<? extends K,? extends V> map)
Similar to
putAll(java.util.Map) except that it removes any entries that exists in
the data map first. |
void |
setLockForChildInsertRemove(boolean lockForChildInsertRemove)
Configures the behaviour of how this node is locked when adding/removing children.
|
void |
setResident(boolean resident) |
Node<K,V> getParent()
null
.Fqn getFqn()
Node<K,V> addChild(Fqn f)
Fqn
under the current node. Returns the newly created node.
If the child exists returns the child node anyway. Guaranteed to return a non-null node.
The Fqn
passed in is relative to the current node. The new child node will have an absolute fqn
calculated as follows: new Fqn(getFqn(), f). See
Fqn
for the operation of this constructor.f
- Fqn
of the child node, relative to the current node.boolean removeChild(Fqn f)
Fqn
.
If you wish to remove children based on absolute Fqn
s, use the Cache
interface instead.f
- Fqn
of the child node, relative to the current node.boolean removeChild(Object childName)
childName
- name of the child node, directly under the current node.Node<K,V> getChild(Fqn f)
f
- Fqn
of the child node. This is a relative Fqn.Node<K,V> getChild(Object name)
name
- name of the child. Note that passing in a String of "/a/b/c" will not return a node called 'c',
3 nodes deep. Instead it will try and look for a child called '/a/b/c' directly under this node.
If you wish to retrieve a child more than one level deep, use the getChild(Fqn)
version of this method.
V put(K key, V value)
key
- key with which the specified value is to be associated.value
- value to be associated with the specified key.V putIfAbsent(K key, V value)
if (!node.getKeys().contains(key)) return node.put(key, value); else return node.get(key);except that this is atomic.
key
- key with which the specified value is to be associated.value
- value to be associated with the specified key.V replace(K key, V value)
if ((node.getKeys().contains(key)) { return node.put(key, value); } else return null;except that this is atomic.
key
- key with which the specified value is associated.value
- value to be associated with the specified key.boolean replace(K key, V oldValue, V newValue)
if (node.get(key).equals(oldValue)) { node.put(key, newValue); return true; } else return false;except that this is atomic.
key
- key with which the specified value is associated.oldValue
- value expected to be associated with the specified key.newValue
- value to be associated with the specified key.void putAll(Map<? extends K,? extends V> map)
Node node; for (Map.Entry me : map.entrySet()) node.put(me.getKey(), me.getValue());
map
- map to copy fromvoid replaceAll(Map<? extends K,? extends V> map)
putAll(java.util.Map)
except that it removes any entries that exists in
the data map first. Note that this happens atomically, under a single lock. This is the analogous
to doing a clearData()
followed by a putAll(java.util.Map)
in the same transaction.map
- map to copy fromV get(K key)
null
if the node contains no mapping for this key.key
- key of the data to returnnull
if the map contains no mapping for this keyV remove(K key)
null
if the node contained no mapping for this keykey
- key whose mapping is to be removednull
if there was no mapping for keyvoid clearData()
int dataSize()
boolean hasChild(Fqn f)
Fqn
passed in exists.boolean hasChild(Object o)
o
- name of the child, relative to the current nodeboolean isValid()
NodeNotValidException
.boolean isResident()
void setResident(boolean resident)
isResident()
boolean isLockForChildInsertRemove()
Configuration.isLockParentForChildInsertRemove()
This can also be configured on a per-node basis using setLockForChildInsertRemove(boolean)
void setLockForChildInsertRemove(boolean lockForChildInsertRemove)
lockForChildInsertRemove
- if true, exclusive locks will be obtained when children are added/removed. If
false, a shared "read lock" will be obtained instead.void releaseObjectReferences(boolean recursive)
recursive
- if true, child nodes will have their object references released as well.boolean isLeaf()
Copyright © 2012 JBoss, a division of Red Hat. All Rights Reserved.