CacheLoader proxy used only when multiple CacheLoaders in a cluster access the same underlying store (e.g.
a shared filesystem, or DB). SharedStoreCacheLoader is a simply facade to a real CacheLoader implementation. It
always delegates reads to the real CacheLoader. Writes are forwarded only if this SharedStoreCacheLoader is
currently the cordinator. This avoid having all CacheLoaders in a cluster writing the same data to the same
underlying store. Although not incorrect (e.g. a DB will just discard additional INSERTs for the same key, and
throw an exception), this will avoid a lot of redundant work.
Whenever the current coordinator dies (or leaves), the second in line will take over. That SharedStoreCacheLoader
will then pass writes through to its underlying CacheLoader.

setCache

Sets the TreeCache that is maintaining this CacheLoader.
This method allows this CacheLoader to invoke methods on TreeCache,
including fetching additional configuration information. This method is
called be called after the CacheLoader instance has been constructed.

getChildrenNames

Returns a set of children node names as Strings.
All names are relative to this parent Fqn.
Returns null if the named node is not found or there are no children.
The returned set must not be modifiable. Implementors can use
Collections.unmodifiableSet(Set) to make the set unmodifiable.

get

Returns all keys and values from the persistent store, given a fully qualified name.
NOTE that the expected return value of this method has changed from JBossCache 1.2.x
and before! This will affect cache loaders written prior to JBossCache 1.3.0 and such
implementations should be checked for compliance with the behaviour expected.

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

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 (note this only holds if the previous
prepare() did not define one_phase=true

loadEntireState

Fetches the entire state for this cache from secondary storage (disk, DB)
and returns it as a byte buffer. This is for initialization of a new
cache from a remote cache. The new cache would then call
CacheLoader.storeEntireState(byte[]).