protected Preferences() 
{

}

Sole constructor. (For invocation by subclass constructors, typically implicit.)

 abstract public String absolutePath()
Returns this preference node's absolute path name.

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

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

 abstract public String[] childrenNames() throws BackingStoreException
Returns the names of the children of this preference node, relative to
this node. (The returned array will be of size zero if this node has
no children.)

 abstract public  void clear() throws BackingStoreException
Removes all of the preferences (key-value associations) in this
preference node. This call has no effect on any descendants
of this node.

If this implementation supports stored defaults, and this
node in the preferences hierarchy contains any such defaults,
the stored defaults will be "exposed" by this call, in the sense that
they will be returned by succeeding calls to get.

 abstract public  void exportNode(OutputStream os) throws IOException, BackingStoreException
Emits on the specified output stream an XML document representing all
of the preferences contained in this node (but not its descendants).
This XML document is, in effect, an offline backup of the node.

The XML document will have the following DOCTYPE declaration:
<!DOCTYPE preferences SYSTEM "http://java.sun.com/dtd/preferences.dtd">

The UTF-8 character encoding will be used.

This method is an exception to the general rule that the results of
concurrently executing multiple methods in this class yields
results equivalent to some serial execution. If the preferences
at this node are modified concurrently with an invocation of this
method, the exported preferences comprise a "fuzzy snapshot" of the
preferences contained in the node; some of the concurrent modifications
may be reflected in the exported data while others may not.

 abstract public  void exportSubtree(OutputStream os) throws IOException, BackingStoreException
Emits an XML document representing all of the preferences contained
in this node and all of its descendants. This XML document is, in
effect, an offline backup of the subtree rooted at the node.

The XML document will have the following DOCTYPE declaration:
<!DOCTYPE preferences SYSTEM "http://java.sun.com/dtd/preferences.dtd">

The UTF-8 character encoding will be used.

This method is an exception to the general rule that the results of
concurrently executing multiple methods in this class yields
results equivalent to some serial execution. If the preferences
or nodes in the subtree rooted at this node are modified concurrently
with an invocation of this method, the exported preferences comprise a
"fuzzy snapshot" of the subtree; some of the concurrent modifications
may be reflected in the exported data while others may not.

 abstract public  void flush() throws BackingStoreException
Forces any changes in the contents of this preference node and its
descendants to the persistent store. Once this method returns
successfully, it is safe to assume that all changes made in the
subtree rooted at this node prior to the method invocation have become
permanent.

Implementations are free to flush changes into the persistent store
at any time. They do not need to wait for this method to be called.

When a flush occurs on a newly created node, it is made persistent,
as are any ancestors (and descendants) that have yet to be made
persistent. Note however that any preference value changes in
ancestors are not guaranteed to be made persistent.

 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.

 abstract public String get(String key,
    String def)
Returns the value associated with the specified key in this preference
node. Returns the specified default if there is no value associated
with the key, or the backing store is inaccessible.

Some implementations may store default values in their backing
stores. If there is no value associated with the specified key
but there is such a stored default, it is returned in
preference to the specified default.

 abstract public boolean getBoolean(String key,
    boolean def)
Returns the boolean value represented by the string associated with the
specified key in this preference node. Valid strings
are "true", which represents true, and "false", which
represents false. Case is ignored, so, for example, "TRUE"
and "False" are also valid. This method is intended for use in
conjunction with #putBoolean .

Returns the specified default if there is no value
associated with the key, the backing store is inaccessible, or if the
associated value is something other than "true" or
"false", ignoring case.

If the implementation supports stored defaults and such a
default exists and is accessible, it is used in preference to the
specified default, unless the stored default is something other than
"true" or "false", ignoring case, in which case the
specified default is used.

 abstract public byte[] getByteArray(String key,
    byte[] def)
Returns the byte array value represented by the string associated with
the specified key in this preference node. Valid strings are
Base64 encoded binary data, as defined in RFC 2045, Section 6.8,
with one minor change: the string must consist solely of characters
from the Base64 Alphabet; no newline characters or
extraneous characters are permitted. This method is intended for use
in conjunction with #putByteArray .

Returns the specified default if there is no value
associated with the key, the backing store is inaccessible, or if the
associated value is not a valid Base64 encoded byte array
(as defined above).

If the implementation supports stored defaults and such a
default exists and is accessible, it is used in preference to the
specified default, unless the stored default is not a valid Base64
encoded byte array (as defined above), in which case the
specified default is used.

 abstract public double getDouble(String key,
    double def)
Returns the double value represented by the string associated with the
specified key in this preference node. The string is converted to an
integer as by Double#parseDouble(String) . Returns the specified
default if there is no value associated with the key, the backing store
is inaccessible, or if Double.parseDouble(String) would throw a
NumberFormatException  if the associated value were passed.
This method is intended for use in conjunction with #putDouble .

If the implementation supports stored defaults and such a
default exists, is accessible, and could be converted to a double
with Double.parseDouble, this double is returned in preference
to the specified default.

 abstract public float getFloat(String key,
    float def)
Returns the float value represented by the string associated with the
specified key in this preference node. The string is converted to an
integer as by Float#parseFloat(String) . Returns the specified
default if there is no value associated with the key, the backing store
is inaccessible, or if Float.parseFloat(String) would throw a
NumberFormatException  if the associated value were passed.
This method is intended for use in conjunction with #putFloat .

If the implementation supports stored defaults and such a
default exists, is accessible, and could be converted to a float
with Float.parseFloat, this float is returned in preference to
the specified default.

 abstract public int getInt(String key,
    int def)
Returns the int value represented by the string associated with the
specified key in this preference node. The string is converted to
an integer as by Integer#parseInt(String) . Returns the
specified default if there is no value associated with the key,
the backing store is inaccessible, or if
Integer.parseInt(String) would throw a NumberFormatException  if the associated value were passed. This
method is intended for use in conjunction with #putInt .

If the implementation supports stored defaults and such a
default exists, is accessible, and could be converted to an int
with Integer.parseInt, this int is returned in preference to
the specified default.

 abstract public long getLong(String key,
    long def)
Returns the long value represented by the string associated with the
specified key in this preference node. The string is converted to
a long as by Long#parseLong(String) . Returns the
specified default if there is no value associated with the key,
the backing store is inaccessible, or if
Long.parseLong(String) would throw a NumberFormatException  if the associated value were passed. This
method is intended for use in conjunction with #putLong .

If the implementation supports stored defaults and such a
default exists, is accessible, and could be converted to a long
with Long.parseLong, this long is returned in preference to
the specified default.

 public static  void importPreferences(InputStream is) throws IOException, InvalidPreferencesFormatException 
{
        XmlSupport.importPreferences(is);
}

Imports all of the preferences represented by the XML document on the specified input stream. The document may represent user preferences or system preferences. If it represents user preferences, the preferences will be imported into the calling user's preference tree (even if they originally came from a different user's preference tree). If any of the preferences described by the document inhabit preference nodes that do not exist, the nodes will be created.

The XML document must have the following DOCTYPE declaration:

<!DOCTYPE preferences SYSTEM "http://java.sun.com/dtd/preferences.dtd">

(This method is designed for use in conjunction with #exportNode(OutputStream) and #exportSubtree(OutputStream) .

This method is an exception to the general rule that the results of concurrently executing multiple methods in this class yields results equivalent to some serial execution. The method behaves as if implemented on top of the other public methods in this class, notably #node(String) and #put(String, String) .

 abstract public boolean isUserNode()
Returns true if this preference node is in the user
preference tree, false if it's in the system preference tree.

 abstract public String[] keys() throws BackingStoreException
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.)

If the implementation supports stored defaults and there
are any such defaults at this node that have not been overridden,
by explicit preferences, the defaults are returned in the array in
addition to any explicit preferences.

 abstract public String name()
Returns this preference node's name, relative to its parent.

 abstract public Preferences node(String pathName)
Returns the named preference node in the same tree as this node,
creating it and any of its ancestors if they do not already exist.
Accepts a relative or absolute path name. Relative path names
(which do not begin with the slash character ('/')) are
interpreted relative to this preference node.

If the returned node did not exist prior to this call, this node and
any ancestors that were created by this call are not guaranteed
to become permanent until the flush method is called on
the returned node (or one of its ancestors or descendants).

 abstract public boolean nodeExists(String pathName) throws BackingStoreException
Returns true if the named preference node exists in the same tree
as this node. Relative path names (which do not begin with the slash
character ('/')) are interpreted relative to this preference
node.

If this node (or an ancestor) has already been removed with the
#removeNode()  method, it is legal to invoke this method,
but only with the path name ""; the invocation will return
false. Thus, the idiom p.nodeExists("") may be
used to test whether p has been removed.

 abstract public Preferences parent()
Returns the parent of this preference node, or null if this is
the root.

 abstract public  void put(String key,
    String value)
Associates the specified value with the specified key in this
preference node.

 abstract public  void putBoolean(String key,
    boolean value)
Associates a string representing the specified boolean value with the
specified key in this preference node. The associated string is
"true" if the value is true, and "false" if it is
false. This method is intended for use in conjunction with
#getBoolean .

 abstract public  void putByteArray(String key,
    byte[] value)
Associates a string representing the specified byte array with the
specified key in this preference node. The associated string is
the Base64 encoding of the byte array, as defined in RFC 2045, Section 6.8,
with one minor change: the string will consist solely of characters
from the Base64 Alphabet; it will not contain any newline
characters. Note that the maximum length of the byte array is limited
to three quarters of MAX_VALUE_LENGTH so that the length
of the Base64 encoded String does not exceed MAX_VALUE_LENGTH.
This method is intended for use in conjunction with
#getByteArray .

 abstract public  void putDouble(String key,
    double value)
Associates a string representing the specified double value with the
specified key in this preference node. The associated string is the
one that would be returned if the double value were passed to
Double#toString(double) . This method is intended for use in
conjunction with #getDouble .

 abstract public  void putFloat(String key,
    float value)
Associates a string representing the specified float value with the
specified key in this preference node. The associated string is the
one that would be returned if the float value were passed to
Float#toString(float) . This method is intended for use in
conjunction with #getFloat .

 abstract public  void putInt(String key,
    int value)
Associates a string representing the specified int value with the
specified key in this preference node. The associated string is the
one that would be returned if the int value were passed to
Integer#toString(int) . This method is intended for use in
conjunction with #getInt .

 abstract public  void putLong(String key,
    long value)
Associates a string representing the specified long value with the
specified key in this preference node. The associated string is the
one that would be returned if the long value were passed to
Long#toString(long) . This method is intended for use in
conjunction with #getLong .

 abstract public  void remove(String key)
Removes the value associated with the specified key in this preference
node, if any.

If this implementation supports stored defaults, and there is
such a default for the specified preference, the stored default will be
"exposed" by this call, in the sense that it will be returned
by a succeeding call to get.

 abstract public  void removeNode() throws BackingStoreException
Removes this preference node and all of its descendants, invalidating
any preferences contained in the removed nodes. Once a node has been
removed, attempting any method other than #name() ,
#absolutePath() , #isUserNode() , #flush()  or
 nodeExists("")  on the corresponding
Preferences instance will fail with an
IllegalStateException. (The methods defined on Object 
can still be invoked on a node after it has been removed; they will not
throw IllegalStateException.)

The removal is not guaranteed to be persistent until the
flush method is called on this node (or an ancestor).

If this implementation supports stored defaults, removing a
node exposes any stored defaults at or below this node. Thus, a
subsequent call to nodeExists on this node's path name may
return true, and a subsequent call to node on this
path name may return a (different) Preferences instance
representing a non-empty collection of preferences and/or children.

 abstract public  void removeNodeChangeListener(NodeChangeListener ncl)
Removes the specified NodeChangeListener, so it no longer
receives change events.

 abstract public  void removePreferenceChangeListener(PreferenceChangeListener pcl)
Removes the specified preference change listener, so it no longer
receives preference change events.

 abstract public  void sync() throws BackingStoreException
Ensures that future reads from this preference node and its
descendants reflect any changes that were committed to the persistent
store (from any VM) prior to the sync invocation. As a
side-effect, forces any changes in the contents of this preference node
and its descendants to the persistent store, as if the flush
method had been invoked on this node.

 public static Preferences systemNodeForPackage(Class c) 
{
        return systemRoot().node(nodeName(c));
}

Returns the preference node from the system preference tree that is associated (by convention) with the specified class's package. The convention is as follows: the absolute path name of the node is the fully qualified package name, preceded by a slash ('/'), and with each period ('.') replaced by a slash. For example the absolute path name of the node associated with the class com.acme.widget.Foo is /com/acme/widget.

This convention does not apply to the unnamed package, whose associated preference node is <unnamed>. This node is not intended for long term use, but for convenience in the early development of programs that do not yet belong to a package, and for "throwaway" programs. Valuable data should not be stored at this node as it is shared by all programs that use it.

A class Foo wishing to access preferences pertaining to its package can obtain a preference node as follows:

static Preferences prefs = Preferences.systemNodeForPackage(Foo.class);

This idiom obviates the need for using a string to describe the preferences node and decreases the likelihood of a run-time failure. (If the class name is misspelled, it will typically result in a compile-time error.)

Invoking this method will result in the creation of the returned node and its ancestors if they do not already exist. If the returned node did not exist prior to this call, this node and any ancestors that were created by this call are not guaranteed to become permanent until the flush method is called on the returned node (or one of its ancestors or descendants).

 public static Preferences systemRoot() 
{
        SecurityManager security = System.getSecurityManager();
        if (security != null)
            security.checkPermission(prefsPerm);
        return factory.systemRoot();
}

Returns the root preference node for the system.

 abstract public String toString()
Returns a string representation of this preferences node,
as if computed by the expression:(this.isUserNode() ? "User" :
"System") + " Preference Node: " + this.absolutePath().

 public static Preferences userNodeForPackage(Class c) 
{
                                                                                                                                                                                                                                                                                                                                                      
        return userRoot().node(nodeName(c));
}

Returns the preference node from the calling user's preference tree that is associated (by convention) with the specified class's package. The convention is as follows: the absolute path name of the node is the fully qualified package name, preceded by a slash ('/'), and with each period ('.') replaced by a slash. For example the absolute path name of the node associated with the class com.acme.widget.Foo is /com/acme/widget.

This convention does not apply to the unnamed package, whose associated preference node is <unnamed>. This node is not intended for long term use, but for convenience in the early development of programs that do not yet belong to a package, and for "throwaway" programs. Valuable data should not be stored at this node as it is shared by all programs that use it.

A class Foo wishing to access preferences pertaining to its package can obtain a preference node as follows:

static Preferences prefs = Preferences.userNodeForPackage(Foo.class);

This idiom obviates the need for using a string to describe the preferences node and decreases the likelihood of a run-time failure. (If the class name is misspelled, it will typically result in a compile-time error.)

Invoking this method will result in the creation of the returned node and its ancestors if they do not already exist. If the returned node did not exist prior to this call, this node and any ancestors that were created by this call are not guaranteed to become permanent until the flush method is called on the returned node (or one of its ancestors or descendants).

 public static Preferences userRoot() 
{
                                                    
        SecurityManager security = System.getSecurityManager();
        if (security != null)
            security.checkPermission(prefsPerm);
        return factory.userRoot();
}

Returns the root preference node for the calling user.