The SPI methods fall into three groups concerning exception
behavior. The getSpi method should never throw exceptions, but it
doesn't really matter, as any exception thrown by this method will be
intercepted by get(String,String), which will return the specified
default value to the caller. The removeNodeSpi, keysSpi,
childrenNamesSpi, syncSpi and flushSpi methods are specified
to throw BackingStoreException, and the implementation is required
to throw this checked exception if it is unable to perform the operation.
The exception propagates outward, causing the corresponding API method
to fail.

The remaining SPI methods putSpi(String,String), removeSpi(String) and childSpi(String) have more complicated
exception behavior. They are not specified to throw
BackingStoreException, as they can generally obey their contracts
even if the backing store is unavailable. This is true because they return
no information and their effects are not required to become permanent until
a subsequent call to Preferences.flush() or
Preferences.sync(). Generally speaking, these SPI methods should not
throw exceptions. In some implementations, there may be circumstances
under which these calls cannot even enqueue the requested operation for
later processing. Even under these circumstances it is generally better to
simply ignore the invocation and return, rather than throwing an
exception. Under these circumstances, however, all subsequent invocations
of flush() and sync should return false, as
returning true would imply that all previous operations had
successfully been made permanent.

There is one circumstance under which putSpi, removeSpi and
childSpishould throw an exception: if the caller lacks
sufficient privileges on the underlying operating system to perform the
requested operation. This will, for instance, occur on most systems
if a non-privileged user attempts to modify system preferences.
(The required privileges will vary from implementation to
implementation. On some implementations, they are the right to modify the
contents of some directory in the file system; on others they are the right
to modify contents of some key in a registry.) Under any of these
circumstances, it would generally be undesirable to let the program
continue executing as if these operations would become permanent at a later
time. While implementations are not required to throw an exception under
these circumstances, they are encouraged to do so. A SecurityException would be appropriate.

Most of the SPI methods require the implementation to read or write
information at a preferences node. The implementor should beware of the
fact that another VM may have concurrently deleted this node from the
backing store. It is the implementation's responsibility to recreate the
node if it has been deleted.

Implementation note: In Sun's default Preferences
implementations, the user's identity is inherited from the underlying
operating system and does not change for the lifetime of the virtual
machine. It is recognized that server-side Preferences
implementations may have the user identity change from request to request,
implicitly passed to Preferences methods via the use of a
static ThreadLocal instance. Authors of such implementations are
strongly encouraged to determine the user at the time preferences
are accessed (for example by the get(String,String) or put(String,String) method) rather than permanently associating a user
with each Preferences instance. The latter behavior conflicts
with normal Preferences usage and would lead to great confusion.

Field Detail

newNode

protected boolean newNode

This field should be true if this node did not exist in the
backing store prior to the creation of this object. The field
is initialized to false, but may be set to true by a subclass
constructor (and should not be modified thereafter). This field
indicates whether a node change event should be fired when
creation is complete.

lock

An object whose monitor is used to lock this node. This object
is used in preference to the node itself to reduce the likelihood of
intentional or unintentional denial of service due to a locked node.
To avoid deadlock, a node is never locked by a thread that
holds a lock on a descendant of that node.

Method Detail

put

This implementation checks that the key and value are legal,
obtains this preference node's lock, checks that the node
has not been removed, invokes putSpi(String,String), and if
there are any preference change listeners, enqueues a notification
event for processing by the event dispatch thread.

get

This implementation first checks to see if key is
null throwing a NullPointerException if this is
the case. Then it obtains this preference node's lock,
checks that the node has not been removed, invokes getSpi(String), and returns the result, unless the getSpi
invocation returns null or throws an exception, in which case
this invocation returns def.

remove

This implementation obtains this preference node's lock,
checks that the node has not been removed, invokes
removeSpi(String) and if there are any preference
change listeners, enqueues a notification event for processing by the
event dispatch thread.

getInt

This implementation invokes get(key,
null). If the return value is non-null, the implementation
attempts to translate it to an int with
Integer.parseInt(String). If the attempt succeeds, the return
value is returned by this method. Otherwise, def is returned.

getLong

This implementation invokes get(key,
null). If the return value is non-null, the implementation
attempts to translate it to a long with
Long.parseLong(String). If the attempt succeeds, the return
value is returned by this method. Otherwise, def is returned.

getBoolean

This implementation invokes get(key,
null). If the return value is non-null, it is compared with
"true" using String.equalsIgnoreCase(String). If the
comparison returns true, this invocation returns
true. Otherwise, the original return value is compared with
"false", again using String.equalsIgnoreCase(String).
If the comparison returns true, this invocation returns
false. Otherwise, this invocation returns def.

getFloat

This implementation invokes get(key,
null). If the return value is non-null, the implementation
attempts to translate it to an float with
Float.parseFloat(String). If the attempt succeeds, the return
value is returned by this method. Otherwise, def is returned.

getDouble

This implementation invokes get(key,
null). If the return value is non-null, the implementation
attempts to translate it to an double with
Double.parseDouble(String). If the attempt succeeds, the return
value is returned by this method. Otherwise, def is returned.

childrenNames

This implementation obtains this preference node's lock, checks that
the node has not been removed, constructs a TreeSet initialized
to the names of children already cached (the children in this node's
"child-cache"), invokes childrenNamesSpi(), and adds all of the
returned child-names into the set. The elements of the tree set are
dumped into a String array using the toArray method,
and this array is returned.

node

This implementation obtains this preference node's lock and checks
that the node has not been removed. If path is "",
this node is returned; if path is "/", this node's
root is returned. If the first character in path is
not '/', the implementation breaks path into
tokens and recursively traverses the path from this node to the
named node, "consuming" a name and a slash from path at
each step of the traversal. At each step, the current node is locked
and the node's child-cache is checked for the named node. If it is
not found, the name is checked to make sure its length does not
exceed MAX_NAME_LENGTH. Then the childSpi(String)
method is invoked, and the result stored in this node's child-cache.
If the newly created Preferences object's newNode
field is true and there are any node change listeners,
a notification event is enqueued for processing by the event dispatch
thread.

When there are no more tokens, the last value found in the
child-cache or returned by childSpi is returned by this
method. If during the traversal, two "/" tokens occur
consecutively, or the final token is "/" (rather than a name),
an appropriate IllegalArgumentException is thrown.

If the first character of path is '/'
(indicating an absolute path name) this preference node's
lock is dropped prior to breaking path into tokens, and
this method recursively traverses the path starting from the root
(rather than starting from this node). The traversal is otherwise
identical to the one described for relative path names. Dropping
the lock on this node prior to commencing the traversal at the root
node is essential to avoid the possibility of deadlock, as per the
locking invariant.

removeNode

This implementation checks to see that this node is the root; if so,
it throws an appropriate exception. Then, it locks this node's parent,
and calls a recursive helper method that traverses the subtree rooted at
this node. The recursive method locks the node on which it was called,
checks that it has not already been removed, and then ensures that all
of its children are cached: The childrenNamesSpi() method is
invoked and each returned child name is checked for containment in the
child-cache. If a child is not already cached, the childSpi(String) method is invoked to create a Preferences
instance for it, and this instance is put into the child-cache. Then
the helper method calls itself recursively on each node contained in its
child-cache. Next, it invokes removeNodeSpi(), marks itself
as removed, and removes itself from its parent's child-cache. Finally,
if there are any node change listeners, it enqueues a notification
event for processing by the event dispatch thread.

Note that the helper method is always invoked with all ancestors up
to the "closest non-removed ancestor" locked.

absolutePath

This implementation merely returns the absolute path name that
was computed at the time that this node was constructed (based on
the name that was passed to this node's constructor, and the names
that were passed to this node's ancestors' constructors).

isUserNode

This implementation compares this node's root node (which is stored
in a private field) with the value returned by
Preferences.userRoot(). If the two object references are
identical, this method returns true.

addPreferenceChangeListener

Registers the specified listener to receive preference change
events for this preference node. A preference change event is
generated when a preference is added to this node, removed from this
node, or when the value associated with a preference is changed.
(Preference change events are not generated by the Preferences.removeNode() method, which generates a node change event.
Preference change events are generated by the clear
method.)

Events are only guaranteed for changes made within the same JVM
as the registered listener, though some implementations may generate
events for changes made outside this JVM. Events may be generated
before the changes have been made persistent. Events are not generated
when preferences are modified in descendants of this node; a caller
desiring such events must register with each descendant.

addNodeChangeListener

Registers the specified listener to receive node change events
for this node. A node change event is generated when a child node is
added to or removed from this node. (A single Preferences.removeNode()
invocation results in multiple node change events, one for every
node in the subtree rooted at the removed node.)

Events are only guaranteed for changes made within the same JVM
as the registered listener, though some implementations may generate
events for changes made outside this JVM. Events may be generated
before the changes have become permanent. Events are not generated
when indirect descendants of this node are added or removed; a
caller desiring such events must register with each descendant.

Few guarantees can be made regarding node creation. Because nodes
are created implicitly upon access, it may not be feasible for an
implementation to determine whether a child node existed in the backing
store prior to access (for example, because the backing store is
unreachable or cached information is out of date). Under these
circumstances, implementations are neither required to generate node
change events nor prohibited from doing so.

putSpi

Put the given key-value association into this preference node. It is
guaranteed that key and value are non-null and of
legal length. Also, it is guaranteed that this node has not been
removed. (The implementor needn't check for any of these things.)

This method is invoked with the lock on this node held.

getSpi

Return the value associated with the specified key at this preference
node, or null if there is no association for this key, or the
association cannot be determined at this time. It is guaranteed that
key is non-null. Also, it is guaranteed that this node has
not been removed. (The implementor needn't check for either of these
things.)

Generally speaking, this method should not throw an exception
under any circumstances. If, however, if it does throw an exception,
the exception will be intercepted and treated as a null
return value.

This method is invoked with the lock on this node held.

Returns:

the value associated with the specified key at this preference
node, or null if there is no association for this
key, or the association cannot be determined at this time.

removeSpi

Remove the association (if any) for the specified key at this
preference node. It is guaranteed that key is non-null.
Also, it is guaranteed that this node has not been removed.
(The implementor needn't check for either of these things.)

This method is invoked with the lock on this node held.

removeNodeSpi

Removes this preference node, invalidating it and any preferences that
it contains. The named child will have no descendants at the time this
invocation is made (i.e., the Preferences.removeNode() method
invokes this method repeatedly in a bottom-up fashion, removing each of
a node's descendants before removing the node itself).

This method is invoked with the lock held on this node and its
parent (and all ancestors that are being removed as a
result of a single invocation to Preferences.removeNode()).

The removal of a node needn't become persistent until the
flush method is invoked on this node (or an ancestor).

If this node throws a BackingStoreException, the exception
will propagate out beyond the enclosing removeNode()
invocation.

Throws:

BackingStoreException - if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.

keysSpi

Returns all of the keys that have an associated value in this
preference node. (The returned array will be of size zero if
this node has no preferences.) It is guaranteed that this node has not
been removed.

This method is invoked with the lock on this node held.

If this node throws a BackingStoreException, the exception
will propagate out beyond the enclosing keys() invocation.

Returns:

an array of the keys that have an associated value in this
preference node.

Throws:

BackingStoreException - if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.

childrenNamesSpi

Returns the names of the children of this preference node. (The
returned array will be of size zero if this node has no children.)
This method need not return the names of any nodes already cached,
but may do so without harm.

This method is invoked with the lock on this node held.

If this node throws a BackingStoreException, the exception
will propagate out beyond the enclosing childrenNames()
invocation.

Returns:

an array containing the names of the children of this
preference node.

Throws:

BackingStoreException - if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.

getChild

Returns the named child if it exists, or null if it does not.
It is guaranteed that nodeName is non-null, non-empty,
does not contain the slash character ('/'), and is no longer than
Preferences.MAX_NAME_LENGTH characters. Also, it is guaranteed
that this node has not been removed. (The implementor needn't check
for any of these things if he chooses to override this method.)

Finally, it is guaranteed that the named node has not been returned
by a previous invocation of this method or childSpi(java.lang.String) after the
last time that it was removed. In other words, a cached value will
always be used in preference to invoking this method. (The implementor
needn't maintain his own cache of previously returned children if he
chooses to override this method.)

This implementation obtains this preference node's lock, invokes
childrenNames() to get an array of the names of this node's
children, and iterates over the array comparing the name of each child
with the specified node name. If a child node has the correct name,
the childSpi(String) method is invoked and the resulting
node is returned. If the iteration completes without finding the
specified name, null is returned.

Parameters:

nodeName - name of the child to be searched for.

Returns:

the named child if it exists, or null if it does not.

Throws:

BackingStoreException - if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.

childSpi

Returns the named child of this preference node, creating it if it does
not already exist. It is guaranteed that name is non-null,
non-empty, does not contain the slash character ('/'), and is no longer
than Preferences.MAX_NAME_LENGTH characters. Also, it is guaranteed that
this node has not been removed. (The implementor needn't check for any
of these things.)

Finally, it is guaranteed that the named node has not been returned
by a previous invocation of this method or getChild(String)
after the last time that it was removed. In other words, a cached
value will always be used in preference to invoking this method.
Subclasses need not maintain their own cache of previously returned
children.

The implementer must ensure that the returned node has not been
removed. If a like-named child of this node was previously removed, the
implementer must return a newly constructed AbstractPreferences
node; once removed, an AbstractPreferences node
cannot be "resuscitated."

If this method causes a node to be created, this node is not
guaranteed to be persistent until the flush method is
invoked on this node or one of its ancestors (or descendants).

This method is invoked with the lock on this node held.

Parameters:

name - The name of the child node to return, relative to
this preference node.

sync

This implementation calls a recursive helper method that locks this
node, invokes syncSpi() on it, unlocks this node, and recursively
invokes this method on each "cached child." A cached child is a child
of this node that has been created in this VM and not subsequently
removed. In effect, this method does a depth first traversal of the
"cached subtree" rooted at this node, calling syncSpi() on each node in
the subTree while only that node is locked. Note that syncSpi() is
invoked top-down.

syncSpi

This method is invoked with this node locked. The contract of this
method is to synchronize any cached preferences stored at this node
with any stored in the backing store. (It is perfectly possible that
this node does not exist on the backing store, either because it has
been deleted by another VM, or because it has not yet been created.)
Note that this method should not synchronize the preferences in
any subnodes of this node. If the backing store naturally syncs an
entire subtree at once, the implementer is encouraged to override
sync(), rather than merely overriding this method.

If this node throws a BackingStoreException, the exception
will propagate out beyond the enclosing sync() invocation.

Throws:

BackingStoreException - if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.

flush

This implementation calls a recursive helper method that locks this
node, invokes flushSpi() on it, unlocks this node, and recursively
invokes this method on each "cached child." A cached child is a child
of this node that has been created in this VM and not subsequently
removed. In effect, this method does a depth first traversal of the
"cached subtree" rooted at this node, calling flushSpi() on each node in
the subTree while only that node is locked. Note that flushSpi() is
invoked top-down.

If this method is invoked on a node that has been removed with
the removeNode() method, flushSpi() is invoked on this node,
but not on others.

flushSpi

This method is invoked with this node locked. The contract of this
method is to force any cached changes in the contents of this
preference node to the backing store, guaranteeing their persistence.
(It is perfectly possible that this node does not exist on the backing
store, either because it has been deleted by another VM, or because it
has not yet been created.) Note that this method should not
flush the preferences in any subnodes of this node. If the backing
store naturally flushes an entire subtree at once, the implementer is
encouraged to override flush(), rather than merely overriding this
method.

If this node throws a BackingStoreException, the exception
will propagate out beyond the enclosing flush() invocation.

Throws:

BackingStoreException - if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.

isRemoved

protected boolean isRemoved()

Returns true iff this node (or an ancestor) has been
removed with the removeNode() method. This method
locks this node prior to returning the contents of the private
field used to track this state.

Returns:

true iff this node (or an ancestor) has been
removed with the removeNode() method.