put

Puts all entries of the map into the existing map of the given node,
overwriting existing keys, but not clearing the existing map before
insertion.
This is the same behavior as Map.putAll(java.util.Map extends K, ? extends V>).
If the node does not exist, all parent nodes from the root down are created automatically

Note since 3.0, as an optimization, this method will require a definitive attribute map and
not just a subset. This will allow cache loader implementations to overwrite rather than merge, if that is
deemed more efficient. This will not break backward compatibility since performing a merge will not cause
any loss of data even though it is an unnecessary step.

prepare

Prepares a list of modifications. For example, for a DB-based CacheLoader:

Create a local (JDBC) transaction

Associate the local transaction with tx (tx is the key)

Execute the corresponding SQL statements against the DB (statements derived from modifications)

For non-transactional CacheLoader (e.g. file-based), the implementation could attempt to implement its own transactional
logic, attempting to write data to a temp location (or memory) and writing it to the proper location upon commit.

commit

Commits the transaction. A DB-based CacheLoader would look up the local
JDBC transaction asociated with tx and commit that
transaction. Non-transactional CacheLoaders could simply write the data
that was previously saved transiently under the given tx
key, to (for example) a file system.

storeEntireState

Stores the entire state for this cache by reading it from a provided ObjectInputStream.
The state was provided to this cache by calling CacheLoader.loadEntireState(ObjectOutputStream)}
on some other cache instance. State currently in storage gets overwritten.

Implementations of this method should not catch any exception or close the
given ObjectInputStream parameter. In order to ensure cacheloader interoperability
contents of the cache are read from the ObjectInputStream as a sequence of
NodeData objects.

storeState

Stores the given portion of the cache tree's state in secondary storage.
Overwrite whatever is currently in secondary storage. If the transferred
state has Fqns equal to or children of parameter subtree,
then no special behavior is required. Otherwise, ensure that
the state is integrated under the given subtree. Typically
in the latter case subtree would be the Fqn of the buddy
backup region for
a buddy group; e.g.

If the the transferred state had Fqns starting with "/a" and
subtree was "/_BUDDY_BACKUP_/192.168.1.2:5555" then the
state should be stored in the local persistent store under
"/_BUDDY_BACKUP_/192.168.1.2:5555/a"

Implementations of this method should not catch any exception or close the
given ObjectInputStream parameter. In order to ensure cacheloader interoperability
contents of the cache are read from the ObjectInputStream as a sequence of
NodeData objects.

subtree - Fqn naming the root (i.e. highest level parent) node of
the subtree included in state. If the Fqns
of the data included in state are not
already children of subtree, then their
Fqns should be altered to make them children of
subtree before they are persisted.