| |||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
public abstract class AbstractPreferences extends Preferences
This class provides a skeletal implementation of the {@link Preferences} class, greatly easing the task of implementing it.
This class is for Preferences implementers only. Normal users of the Preferences facility should have no need to consult this documentation. The {@link Preferences} documentation should suffice.
Implementors must override the nine abstract service-provider interface (SPI) methods: {@link #getSpi(String)}, {@link #putSpi(String,String)}, {@link #removeSpi(String)}, {@link #childSpi(String)}, {@link #removeNodeSpi()}, {@link #keysSpi()}, {@link #childrenNamesSpi()}, {@link #syncSpi()} and {@link #flushSpi()}. All of the concrete methods specify precisely how they are implemented atop these SPI methods. The implementor may, at his discretion, override one or more of the concrete methods if the default implementation is unsatisfactory for any reason, such as performance.
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 {@link #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 {@link 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 {@link #putSpi(String,String)}, {@link #removeSpi(String)} and {@link #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 {@link Preferences#flush()} or {@link 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 childSpi should 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 {@link 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 {@link ThreadLocal} instance. Authors of such implementations are strongly encouraged to determine the user at the time preferences are accessed (for example by the {@link #get(String,String)} or {@link #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 Summary | |
---|---|
protected Object |
lock
An object whose monitor is used to lock this node. |
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. |
Fields inherited from class java.util.prefs.Preferences |
---|
MAX_KEY_LENGTH, MAX_NAME_LENGTH, MAX_VALUE_LENGTH |
Constructor Summary | |
---|---|
protected |
AbstractPreferences(AbstractPreferences parent, String name) Creates a preference node with the specified parent and the specified name relative to its parent. |
Method Summary | |
---|---|
String |
Implements the absolutePath method as per the specification in java.util.prefs.Preferences.absolutePath. |
void |
Registers the specified listener to receive node change events for this node. |
void |
Registers the specified listener to receive preference change events for this preference node. |
protected AbstractPreferences[] |
Returns all known unremoved children of this node. |
String[] |
Implements the children method as per the specification in java.util.prefs.Preferences.childrenNames. |
protected abstract String[] |
Returns the names of the children of this preference node. |
protected abstract AbstractPreferences |
Returns the named child of this preference node, creating it if it does not already exist. |
void |
clear() Implements the clear method as per the specification in java.util.prefs.Preferences.clear. |
void |
Implements the exportNode method as per the specification in java.util.prefs.Preferences.exportNode. |
void |
Implements the exportSubtree method as per the specification in java.util.prefs.Preferences.exportSubtree. |
void |
flush() Implements the flush method as per the specification in java.util.prefs.Preferences.flush. |
protected abstract void |
flushSpi() This method is invoked with this node locked. |
String |
Implements the get method as per the specification in java.util.prefs.Preferences.get. |
boolean |
getBoolean(String key, boolean def) Implements the getBoolean method as per the specification in java.util.prefs.Preferences.getBoolean. |
byte[] |
getByteArray(String key, byte[] def) Implements the getByteArray method as per the specification in java.util.prefs.Preferences.getByteArray. |
protected AbstractPreferences |
Returns the named child if it exists, or null if it does not. |
double |
Implements the getDouble method as per the specification in java.util.prefs.Preferences.getDouble. |
float |
Implements the getFloat method as per the specification in java.util.prefs.Preferences.getFloat. |
int |
Implements the getInt method as per the specification in java.util.prefs.Preferences.getInt. |
long |
Implements the getLong method as per the specification in java.util.prefs.Preferences.getLong. |
protected abstract String |
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. |
protected boolean |
Returns true iff this node (or an ancestor) has been removed with the java.util.prefs.AbstractPreferences.removeNode method. |
boolean |
Implements the isUserNode method as per the specification in java.util.prefs.Preferences.isUserNode. |
String[] |
keys() Implements the keys method as per the specification in java.util.prefs.Preferences.keys. |
protected abstract String[] |
keysSpi() Returns all of the keys that have an associated value in this preference node. |
String |
name() Implements the name method as per the specification in java.util.prefs.Preferences.name. |
Preferences |
Implements the node method as per the specification in java.util.prefs.Preferences.node. |
boolean |
nodeExists(String path) Implements the nodeExists method as per the specification in java.util.prefs.Preferences.nodeExists. |
Preferences |
parent() Implements the parent method as per the specification in java.util.prefs.Preferences.parent. |
void |
Implements the put method as per the specification in java.util.prefs.Preferences.put. |
void |
putBoolean(String key, boolean value) Implements the putBoolean method as per the specification in java.util.prefs.Preferences.putBoolean. |
void |
putByteArray(String key, byte[] value) Implements the putByteArray method as per the specification in java.util.prefs.Preferences.putByteArray. |
void |
Implements the putDouble method as per the specification in java.util.prefs.Preferences.putDouble. |
void |
Implements the putFloat method as per the specification in java.util.prefs.Preferences.putFloat. |
void |
Implements the putInt method as per the specification in java.util.prefs.Preferences.putInt. |
void |
Implements the putLong method as per the specification in java.util.prefs.Preferences.putLong. |
protected abstract void |
Put the given key-value association into this preference node. |
void |
Implements the remove(String) method as per the specification in java.util.prefs.Preferences.remove. |
void |
Implements the removeNode() method as per the specification in java.util.prefs.Preferences.removeNode. |
void |
Removes the specified NodeChangeListener, so it no longer receives change events. |
protected abstract void |
Removes this preference node, invalidating it and any preferences that it contains. |
void |
Removes the specified preference change listener, so it no longer receives preference change events. |
protected abstract void |
Remove the association (if any) for the specified key at this preference node. |
void |
sync() Implements the sync method as per the specification in java.util.prefs.Preferences.sync. |
protected abstract void |
syncSpi() This method is invoked with this node locked. |
String |
toString() Returns the absolute path name of this preferences node. |
Methods inherited from class java.util.prefs.Preferences |
---|
absolutePath, addNodeChangeListener, addPreferenceChangeListener, childrenNames, clear, exportNode, exportSubtree, flush, get, getBoolean, getByteArray, getDouble, getFloat, getInt, getLong, importPreferences, isUserNode, keys, name, node, nodeExists, parent, put, putBoolean, putByteArray, putDouble, putFloat, putInt, putLong, remove, removeNode, removeNodeChangeListener, removePreferenceChangeListener, sync, systemNodeForPackage, systemRoot, toString, userNodeForPackage, userRoot |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
---|
protected final Object lock
protected boolean newNode
Constructor Detail |
---|
protected AbstractPreferences(AbstractPreferences parent, String name)
parent
- the parent of this preference node, or null if this
is the root.name
- the name of this preference node, relative to its parent,
or "" if this is the root.Method Detail |
---|
public String 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).
absolutePath
in class Preferences
public void addNodeChangeListener(NodeChangeListener ncl)
addNodeChangeListener
in class Preferences
ncl
public void addPreferenceChangeListener(PreferenceChangeListener pcl)
addPreferenceChangeListener
in class Preferences
pcl
protected final AbstractPreferences[] cachedChildren()
public String[] childrenNames() throws BackingStoreException
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 {@link #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.
childrenNames
in class Preferences
BackingStoreException
- if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.protected abstract String[] childrenNamesSpi() throws BackingStoreException
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 {@link #childrenNames()} invocation.
BackingStoreException
- if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.protected abstract AbstractPreferences childSpi(String name)
Finally, it is guaranteed that the named node has not been returned by a previous invocation of this method or {@link #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.
name
- The name of the child node to return, relative to
this preference node.public void clear() throws BackingStoreException
This implementation obtains this preference node's lock, invokes {@link #keys()} to obtain an array of keys, and iterates over the array invoking {@link #remove(String)} on each key.
clear
in class Preferences
BackingStoreException
- if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.public void exportNode(OutputStream os) throws IOException, BackingStoreException
exportNode
in class Preferences
os
- the output stream on which to emit the XML document.IOException
- if writing to the specified output stream
results in an IOException.BackingStoreException
- if preference data cannot be read from
backing store.public void exportSubtree(OutputStream os) throws IOException, BackingStoreException
exportSubtree
in class Preferences
os
- the output stream on which to emit the XML document.IOException
- if writing to the specified output stream
results in an IOException.BackingStoreException
- if preference data cannot be read from
backing store.public void flush() throws BackingStoreException
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 {@link #removeNode()} method, flushSpi() is invoked on this node, but not on others.
flush
in class Preferences
BackingStoreException
- if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.protected abstract void flushSpi() throws BackingStoreException
If this node throws a BackingStoreException, the exception will propagate out beyond the enclosing {@link #flush()} invocation.
BackingStoreException
- if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.public String get(String key, String def)
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 {@link #getSpi(String)}, and returns the result, unless the getSpi invocation returns null or throws an exception, in which case this invocation returns def.
get
in class Preferences
key
- key whose associated value is to be returned.def
- the value to be returned in the event that this
preference node has no value associated with key.public boolean getBoolean(String key, boolean def)
This implementation invokes {@link #get(String,String) get(key, null)}. If the return value is non-null, it is compared with "true" using {@link String#equalsIgnoreCase(String)}. If the comparison returns true, this invocation returns true. Otherwise, the original return value is compared with "false", again using {@link String#equalsIgnoreCase(String)}. If the comparison returns true, this invocation returns false. Otherwise, this invocation returns def.
getBoolean
in class Preferences
key
- key whose associated value is to be returned as a boolean.def
- the value to be returned in the event that this
preference node has no value associated with key
or the associated value cannot be interpreted as a boolean.public byte[] getByteArray(String key, byte[] def)
getByteArray
in class Preferences
key
- key whose associated value is to be returned as a byte array.def
- the value to be returned in the event that this
preference node has no value associated with key
or the associated value cannot be interpreted as a byte array.protected AbstractPreferences getChild(String nodeName) throws BackingStoreException
Finally, it is guaranteed that the named node has not been returned by a previous invocation of this method or {@link #childSpi} 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 {@link #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 {@link #childSpi(String)} method is invoked and the resulting node is returned. If the iteration completes without finding the specified name, null is returned.
nodeName
- name of the child to be searched for.BackingStoreException
- if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.public double getDouble(String key, double def)
This implementation invokes {@link #get(String,String) get(key, null)}. If the return value is non-null, the implementation attempts to translate it to an double with {@link Double#parseDouble(String)}. If the attempt succeeds, the return value is returned by this method. Otherwise, def is returned.
getDouble
in class Preferences
key
- key whose associated value is to be returned as a double.def
- the value to be returned in the event that this
preference node has no value associated with key
or the associated value cannot be interpreted as a double.public float getFloat(String key, float def)
This implementation invokes {@link #get(String,String) get(key, null)}. If the return value is non-null, the implementation attempts to translate it to an float with {@link Float#parseFloat(String)}. If the attempt succeeds, the return value is returned by this method. Otherwise, def is returned.
getFloat
in class Preferences
key
- key whose associated value is to be returned as a float.def
- the value to be returned in the event that this
preference node has no value associated with key
or the associated value cannot be interpreted as a float.public int getInt(String key, int def)
This implementation invokes {@link #get(String,String) get(key, null)}. If the return value is non-null, the implementation attempts to translate it to an int with {@link Integer#parseInt(String)}. If the attempt succeeds, the return value is returned by this method. Otherwise, def is returned.
getInt
in class Preferences
key
- key whose associated value is to be returned as an int.def
- the value to be returned in the event that this
preference node has no value associated with key
or the associated value cannot be interpreted as an int.public long getLong(String key, long def)
This implementation invokes {@link #get(String,String) get(key, null)}. If the return value is non-null, the implementation attempts to translate it to a long with {@link Long#parseLong(String)}. If the attempt succeeds, the return value is returned by this method. Otherwise, def is returned.
getLong
in class Preferences
key
- key whose associated value is to be returned as a long.def
- the value to be returned in the event that this
preference node has no value associated with key
or the associated value cannot be interpreted as a long.protected abstract String getSpi(String key)
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.
key
protected boolean isRemoved()
public boolean isUserNode()
This implementation compares this node's root node (which is stored in a private field) with the value returned by {@link Preferences#userRoot()}. If the two object references are identical, this method returns true.
isUserNode
in class Preferences
public String[] keys() throws BackingStoreException
This implementation obtains this preference node's lock, checks that the node has not been removed and invokes {@link #keysSpi()}.
keys
in class Preferences
BackingStoreException
- if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.protected abstract String[] keysSpi() throws BackingStoreException
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 {@link #keys()} invocation.
BackingStoreException
- if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.public String name()
This implementation merely returns the name that was passed to this node's constructor.
name
in class Preferences
public Preferences node(String path)
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 {@link #childSpi(String)} method is invoked, and the result stored in this node's child-cache. If the newly created Preferences object's {@link #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 {@link #lock locking invariant}.
node
in class Preferences
path
- the path name of the preference node to return.public boolean nodeExists(String path) throws BackingStoreException
This implementation is very similar to {@link #node(String)}, except that {@link #getChild(String)} is used instead of {@link #childSpi(String)}.
nodeExists
in class Preferences
path
- the path name of the node whose existence is to be checked.BackingStoreException
- if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.public Preferences 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.
parent
in class Preferences
public void put(String key, String value)
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 {@link #putSpi(String,String)}, and if there are any preference change listeners, enqueues a notification event for processing by the event dispatch thread.
put
in class Preferences
key
- key with which the specified value is to be associated.value
- value to be associated with the specified key.public void putBoolean(String key, boolean value)
This implementation translates value to a string with {@link String#valueOf(boolean)} and invokes {@link #put(String,String)} on the result.
putBoolean
in class Preferences
key
- key with which the string form of value is to be associated.value
- value whose string form is to be associated with key.public void putByteArray(String key, byte[] value)
putByteArray
in class Preferences
key
- key with which the string form of value is to be associated.value
- value whose string form is to be associated with key.public void putDouble(String key, double value)
This implementation translates value to a string with {@link Double#toString(double)} and invokes {@link #put(String,String)} on the result.
putDouble
in class Preferences
key
- key with which the string form of value is to be associated.value
- value whose string form is to be associated with key.public void putFloat(String key, float value)
This implementation translates value to a string with {@link Float#toString(float)} and invokes {@link #put(String,String)} on the result.
putFloat
in class Preferences
key
- key with which the string form of value is to be associated.value
- value whose string form is to be associated with key.public void putInt(String key, int value)
This implementation translates value to a string with {@link Integer#toString(int)} and invokes {@link #put(String,String)} on the result.
putInt
in class Preferences
key
- key with which the string form of value is to be associated.value
- value whose string form is to be associated with key.public void putLong(String key, long value)
This implementation translates value to a string with {@link Long#toString(long)} and invokes {@link #put(String,String)} on the result.
putLong
in class Preferences
key
- key with which the string form of value is to be associated.value
- value whose string form is to be associated with key.protected abstract void putSpi(String key, String value)
This method is invoked with the lock on this node held.
key
value
public void remove(String key)
This implementation obtains this preference node's lock, checks that the node has not been removed, invokes {@link #removeSpi(String)} and if there are any preference change listeners, enqueues a notification event for processing by the event dispatch thread.
remove
in class Preferences
key
- key whose mapping is to be removed from the preference node.public void removeNode() throws BackingStoreException
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 {@link #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 {@link #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 {@link #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.
removeNode
in class Preferences
BackingStoreException
- if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.public void removeNodeChangeListener(NodeChangeListener ncl)
removeNodeChangeListener
in class Preferences
ncl
protected abstract void removeNodeSpi() throws BackingStoreException
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 {@link 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 {@link #removeNode()} invocation.
BackingStoreException
- if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.public void removePreferenceChangeListener(PreferenceChangeListener pcl)
removePreferenceChangeListener
in class Preferences
pcl
protected abstract void removeSpi(String key)
This method is invoked with the lock on this node held.
key
public void sync() throws BackingStoreException
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.
sync
in class Preferences
BackingStoreException
- if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.protected abstract void syncSpi() throws BackingStoreException
If this node throws a BackingStoreException, the exception will propagate out beyond the enclosing {@link #sync()} invocation.
BackingStoreException
- if this operation cannot be completed
due to a failure in the backing store, or inability to
communicate with it.public String toString()
toString
in class Preferences
| |||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |