AbstractPreferences

lock

Object 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.

newNode

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.

AbstractPreferences

AbstractPreferences (AbstractPreferences parent, 
                String name)

Creates a preference node with the specified parent and the specified name relative to its parent.

absolutePath

String absolutePath ()

Implements the absolutePath method as per the specification in 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).

addNodeChangeListener

void addNodeChangeListener (NodeChangeListener ncl)

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 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.

addPreferenceChangeListener

void addPreferenceChangeListener (PreferenceChangeListener pcl)

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 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.

childrenNames

String[] childrenNames ()

Implements the children method as per the specification in 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.

clear

void clear ()

Implements the clear method as per the specification in clear().

This implementation obtains this preference node's lock, invokes keys() to obtain an array of keys, and iterates over the array invoking remove(String) on each key.

exportNode

void exportNode (OutputStream os)

Implements the exportNode method as per the specification in exportNode(OutputStream).

exportSubtree

void exportSubtree (OutputStream os)

Implements the exportSubtree method as per the specification in exportSubtree(OutputStream).

flush

void flush ()

Implements the flush method as per the specification in 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.

get

String get (String key, 
                String def)

Implements the get method as per the specification in get(String, String).

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.

getBoolean

boolean getBoolean (String key, 
                boolean def)

Implements the getBoolean method as per the specification in getBoolean(String, boolean).

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

getByteArray

byte[] getByteArray (String key, 
                byte[] def)

Implements the getByteArray method as per the specification in getByteArray(String, byte[]).

getDouble

double getDouble (String key, 
                double def)

Implements the getDouble method as per the specification in getDouble(String, double).

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

getFloat

float getFloat (String key, 
                float def)

Implements the getFloat method as per the specification in getFloat(String, float).

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

getInt

int getInt (String key, 
                int def)

Implements the getInt method as per the specification in getInt(String, int).

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

getLong

long getLong (String key, 
                long def)

Implements the getLong method as per the specification in getLong(String, long).

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

isUserNode

boolean isUserNode ()

Implements the isUserNode method as per the specification in isUserNode().

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

keys

String[] keys ()

Implements the keys method as per the specification in keys().

This implementation obtains this preference node's lock, checks that the node has not been removed and invokes keysSpi().

name

String name ()

Implements the name method as per the specification in name().

This implementation merely returns the name that was passed to this node's constructor.

node

Preferences node (String path)

Implements the node method as per the specification in node(String).

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.

nodeExists

boolean nodeExists (String path)

Implements the nodeExists method as per the specification in nodeExists(String).

This implementation is very similar to node(String), except that getChild(String) is used instead of childSpi(String).

parent

Preferences parent ()

Implements the parent method as per the specification in parent().

This implementation obtains this preference node's lock, checks that the node has not been removed and returns the parent value that was passed to this node's constructor.

put

void put (String key, 
                String value)

Implements the put method as per the specification in put(String, String).

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.

putBoolean

void putBoolean (String key, 
                boolean value)

Implements the putBoolean method as per the specification in putBoolean(String, boolean).

This implementation translates value to a string with valueOf(boolean) and invokes put(String, String) on the result.

putByteArray

void putByteArray (String key, 
                byte[] value)

Implements the putByteArray method as per the specification in putByteArray(String, byte[]).

putDouble

void putDouble (String key, 
                double value)

Implements the putDouble method as per the specification in putDouble(String, double).

This implementation translates value to a string with toString(double) and invokes put(String, String) on the result.

putFloat

void putFloat (String key, 
                float value)

Implements the putFloat method as per the specification in putFloat(String, float).

This implementation translates value to a string with toString(float) and invokes put(String, String) on the result.

putInt

void putInt (String key, 
                int value)

Implements the putInt method as per the specification in putInt(String, int).

This implementation translates value to a string with toString(int) and invokes put(String, String) on the result.

putLong

void putLong (String key, 
                long value)

Implements the putLong method as per the specification in putLong(String, long).

This implementation translates value to a string with toString(long) and invokes put(String, String) on the result.

remove

void remove (String key)

Implements the remove(String) method as per the specification in remove(String).

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.

removeNode

void removeNode ()

Implements the removeNode() method as per the specification in 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.

removeNodeChangeListener

void removeNodeChangeListener (NodeChangeListener ncl)

Removes the specified NodeChangeListener, so it no longer receives change events.

removePreferenceChangeListener

void removePreferenceChangeListener (PreferenceChangeListener pcl)

Removes the specified preference change listener, so it no longer receives preference change events.

sync

void sync ()

Implements the sync method as per the specification in 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.

toString

String toString ()

Returns the absolute path name of this preferences node.

cachedChildren

AbstractPreferences[] cachedChildren ()

Returns all known unremoved children of this node.

childSpi

AbstractPreferences childSpi (String name)

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 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.

childrenNamesSpi

String[] 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.

flushSpi

void 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.

getChild

AbstractPreferences getChild (String nodeName)

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 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(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.

getSpi

String getSpi (String key)

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.

isRemoved

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.

keysSpi

String[] 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.

putSpi

void putSpi (String key, 
                String value)

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.

removeNodeSpi

void 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 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 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.

removeSpi

void removeSpi (String key)

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.

syncSpi

void 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.