protected AbstractPreferences(AbstractPreferences parent,
    String name) 
{
        if (parent==null) {
            if (!name.equals(""))
                throw new IllegalArgumentException("Root name '"+name+
                                                   "' must be \"\"");
            this.absolutePath = "/";
            root = this;
        } else {
            if (name.indexOf('/') != -1)
                throw new IllegalArgumentException("Name '" + name +
                                                 "' contains '/'");
            if (name.equals(""))
              throw new IllegalArgumentException("Illegal name: empty string");
            root = parent.root;
            absolutePath = (parent==root ? "/" + name
                                         : parent.absolutePath() + "/" + name);
        }
        this.name = name;
        this.parent = parent;
}

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

Parameters:

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.

Throws:

IllegalArgumentException - if name contains a slash ('/'), or parent is null and name isn't "".

 public String absolutePath() 
{
        return absolutePath;
}

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

 public  void addNodeChangeListener(NodeChangeListener ncl) 
{
        if (ncl==null)
            throw new NullPointerException("Change listener is null.");
        synchronized(lock) {
            if (removed)
                throw new IllegalStateException("Node has been removed.");
            // Copy-on-write
            if (nodeListeners == null) {
                nodeListeners = new NodeChangeListener[1];
                nodeListeners[0] = ncl;
            } else {
                NodeChangeListener[] old = nodeListeners;
                nodeListeners = new NodeChangeListener[old.length + 1];
                System.arraycopy(old, 0, nodeListeners, 0, old.length);
                nodeListeners[old.length] = ncl;
            }
        }
        startEventDispatchThreadIfNecessary();
}

 public  void addPreferenceChangeListener(PreferenceChangeListener pcl) 
{
        if (pcl==null)
            throw new NullPointerException("Change listener is null.");
        synchronized(lock) {
            if (removed)
                throw new IllegalStateException("Node has been removed.");
            // Copy-on-write
            PreferenceChangeListener[] old = prefListeners;
            prefListeners = new PreferenceChangeListener[old.length + 1];
            System.arraycopy(old, 0, prefListeners, 0, old.length);
            prefListeners[old.length] = pcl;
        }
        startEventDispatchThreadIfNecessary();
}

 protected final AbstractPreferences[] cachedChildren() 
{
        return kidCache.values().toArray(EMPTY_ABSTRACT_PREFS_ARRAY);
}

Returns all known unremoved children of this node.

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

 public String[] childrenNames() throws BackingStoreException 
{
        synchronized(lock) {
            if (removed)
                throw new IllegalStateException("Node has been removed.");
            Set< String > s = new TreeSet<  >(kidCache.keySet());
            for (String kid : childrenNamesSpi())
                s.add(kid);
            return s.toArray(EMPTY_STRING_ARRAY);
        }
}

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

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

 public  void clear() throws BackingStoreException 
{
        synchronized(lock) {
            String[] keys = keys();
            for (int i=0; i< keys.length; i++)
                remove(keys[i]);
        }
}

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

 public  void exportNode(OutputStream os) throws IOException, BackingStoreException 
{
        XmlSupport.export(os, this, false);
}

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

 public  void exportSubtree(OutputStream os) throws IOException, BackingStoreException 
{
        XmlSupport.export(os, this, true);
}

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

 public  void flush() throws BackingStoreException 
{
        flush2();
}

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

 abstract protected  void flushSpi() throws BackingStoreException
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.

 public String get(String key,
    String def) 
{
        if (key==null)
            throw new NullPointerException("Null key");
        synchronized(lock) {
            if (removed)
                throw new IllegalStateException("Node has been removed.");
            String result = null;
            try {
                result = getSpi(key);
            } catch (Exception e) {
                // Ignoring exception causes default to be returned
            }
            return (result==null ? def : result);
        }
}

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

 public boolean getBoolean(String key,
    boolean def) 
{
        boolean result = def;
        String value = get(key, null);
        if (value != null) {
            if (value.equalsIgnoreCase("true"))
                result = true;
            else if (value.equalsIgnoreCase("false"))
                result = false;
        }
        return result;
}

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

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.

 public byte[] getByteArray(String key,
    byte[] def) 
{
        byte[] result = def;
        String value = get(key, null);
        try {
            if (value != null)
                result = Base64.base64ToByteArray(value);
        }
        catch (RuntimeException e) {
            // Ignoring exception causes specified default to be returned
        }
        return result;
}

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

 protected AbstractPreferences getChild(String nodeName) throws BackingStoreException 
{
        synchronized(lock) {
            // assert kidCache.get(nodeName)==null;
            String[] kidNames = childrenNames();
            for (int i=0; i< kidNames.length; i++)
                if (kidNames[i].equals(nodeName))
                    return childSpi(kidNames[i]);
        }
        return null;
}

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

 public double getDouble(String key,
    double def) 
{
        double result = def;
        try {
            String value = get(key, null);
            if (value != null)
                result = Double.parseDouble(value);
        } catch (NumberFormatException e) {
            // Ignoring exception causes specified default to be returned
        }
        return result;
}

Implements the getDouble method as per the specification in Preferences#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 Double#parseDouble(String) . If the attempt succeeds, the return value is returned by this method. Otherwise, def is returned.

 public float getFloat(String key,
    float def) 
{
        float result = def;
        try {
            String value = get(key, null);
            if (value != null)
                result = Float.parseFloat(value);
        } catch (NumberFormatException e) {
            // Ignoring exception causes specified default to be returned
        }
        return result;
}

Implements the getFloat method as per the specification in Preferences#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 Float#parseFloat(String) . If the attempt succeeds, the return value is returned by this method. Otherwise, def is returned.

 public int getInt(String key,
    int def) 
{
        int result = def;
        try {
            String value = get(key, null);
            if (value != null)
                result = Integer.parseInt(value);
        } catch (NumberFormatException e) {
            // Ignoring exception causes specified default to be returned
        }
        return result;
}

Implements the getInt method as per the specification in Preferences#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 Integer#parseInt(String) . If the attempt succeeds, the return value is returned by this method. Otherwise, def is returned.

 public long getLong(String key,
    long def) 
{
        long result = def;
        try {
            String value = get(key, null);
            if (value != null)
                result = Long.parseLong(value);
        } catch (NumberFormatException e) {
            // Ignoring exception causes specified default to be returned
        }
        return result;
}

Implements the getLong method as per the specification in Preferences#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 Long#parseLong(String) . If the attempt succeeds, the return value is returned by this method. Otherwise, def is returned.

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

 protected boolean isRemoved() 
{
        synchronized(lock) {
            return removed;
        }
}

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.

 public boolean isUserNode() 
{
        return AccessController.doPrivileged(
            new PrivilegedAction< Boolean >() {
                public Boolean run() {
                    return root == Preferences.userRoot();
            }
            }).booleanValue();
}

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

 public String[] keys() throws BackingStoreException 
{
        synchronized(lock) {
            if (removed)
                throw new IllegalStateException("Node has been removed.");
            return keysSpi();
        }
}

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

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

 abstract protected String[] keysSpi() 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.)  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.

 public String name() 
{
        return name;
}

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

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

 public Preferences node(String path) 
{
        synchronized(lock) {
            if (removed)
                throw new IllegalStateException("Node has been removed.");
            if (path.equals(""))
                return this;
            if (path.equals("/"))
                return root;
            if (path.charAt(0) != '/')
                return node(new StringTokenizer(path, "/", true));
        }
        // Absolute path.  Note that we've dropped our lock to avoid deadlock
        return root.node(new StringTokenizer(path.substring(1), "/", true));
}

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

 public boolean nodeExists(String path) throws BackingStoreException 
{
        synchronized(lock) {
            if (path.equals(""))
                return !removed;
            if (removed)
                throw new IllegalStateException("Node has been removed.");
            if (path.equals("/"))
                return true;
            if (path.charAt(0) != '/')
                return nodeExists(new StringTokenizer(path, "/", true));
        }
        // Absolute path.  Note that we've dropped our lock to avoid deadlock
        return root.nodeExists(new StringTokenizer(path.substring(1), "/",
                                                   true));
}

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

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

 NodeChangeListener[] nodeListeners() 
{
        synchronized(lock) {
            return nodeListeners;
        }
}

 public Preferences parent() 
{
        synchronized(lock) {
            if (removed)
                throw new IllegalStateException("Node has been removed.");
            return parent;
        }
}

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

 PreferenceChangeListener[] prefListeners() 
{
        synchronized(lock) {
            return prefListeners;
        }
}

Return this node's preference/node change listeners. Even though we're using a copy-on-write lists, we use synchronized accessors to ensure information transmission from the writing thread to the reading thread.

 public  void put(String key,
    String value) 
{
        if (key==null || value==null)
            throw new NullPointerException();
        if (key.length()  > MAX_KEY_LENGTH)
            throw new IllegalArgumentException("Key too long: "+key);
        if (value.length()  > MAX_VALUE_LENGTH)
            throw new IllegalArgumentException("Value too long: "+value);
        synchronized(lock) {
            if (removed)
                throw new IllegalStateException("Node has been removed.");
            putSpi(key, value);
            enqueuePreferenceChangeEvent(key, value);
        }
}

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

 public  void putBoolean(String key,
    boolean value) 
{
        put(key, String.valueOf(value));
}

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

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

 public  void putByteArray(String key,
    byte[] value) 
{
        put(key, Base64.byteArrayToBase64(value));
}

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

 public  void putDouble(String key,
    double value) 
{
        put(key, Double.toString(value));
}

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

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

 public  void putFloat(String key,
    float value) 
{
        put(key, Float.toString(value));
}

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

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

 public  void putInt(String key,
    int value) 
{
        put(key, Integer.toString(value));
}

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

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

 public  void putLong(String key,
    long value) 
{
        put(key, Long.toString(value));
}

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

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

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

 public  void remove(String key) 
{
        synchronized(lock) {
            if (removed)
                throw new IllegalStateException("Node has been removed.");
            removeSpi(key);
            enqueuePreferenceChangeEvent(key, null);
        }
}

Implements the remove(String) method as per the specification in Preferences#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.

 public  void removeNode() throws BackingStoreException 
{
        if (this==root)
            throw new UnsupportedOperationException("Can't remove the root!");
        synchronized(parent.lock) {
            removeNode2();
            parent.kidCache.remove(name);
        }
}

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

 public  void removeNodeChangeListener(NodeChangeListener ncl) 
{
        synchronized(lock) {
            if (removed)
                throw new IllegalStateException("Node has been removed.");
            if ((nodeListeners == null) || (nodeListeners.length == 0))
                throw new IllegalArgumentException("Listener not registered.");
            // Copy-on-write
            int i = 0;
            while (i <  nodeListeners.length && nodeListeners[i] != ncl)
                i++;
            if (i == nodeListeners.length)
                throw new IllegalArgumentException("Listener not registered.");
            NodeChangeListener[] newNl =
                new NodeChangeListener[nodeListeners.length - 1];
            if (i != 0)
                System.arraycopy(nodeListeners, 0, newNl, 0, i);
            if (i != newNl.length)
                System.arraycopy(nodeListeners, i + 1,
                                 newNl, i, newNl.length - i);
            nodeListeners = newNl;
        }
}

 abstract protected  void removeNodeSpi() throws BackingStoreException
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.

 public  void removePreferenceChangeListener(PreferenceChangeListener pcl) 
{
        synchronized(lock) {
            if (removed)
                throw new IllegalStateException("Node has been removed.");
            if ((prefListeners == null) || (prefListeners.length == 0))
                throw new IllegalArgumentException("Listener not registered.");
            // Copy-on-write
            PreferenceChangeListener[] newPl =
                new PreferenceChangeListener[prefListeners.length - 1];
            int i = 0;
            while (i <  newPl.length && prefListeners[i] != pcl)
                newPl[i] = prefListeners[i++];
            if (i == newPl.length &&  prefListeners[i] != pcl)
                throw new IllegalArgumentException("Listener not registered.");
            while (i <  newPl.length)
                newPl[i] = prefListeners[++i];
            prefListeners = newPl;
        }
}

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

 public  void sync() throws BackingStoreException 
{
        sync2();
}

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

 abstract protected  void syncSpi() throws BackingStoreException
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.

 public String toString() 
{
        return (this.isUserNode() ? "User" : "System") +
               " Preference Node: " + this.absolutePath();
}

Returns the absolute path name of this preferences node.