/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.util.prefs;

import java.util.*;

import java.io.*;

import java.security.AccessController;

import java.security.PrivilegedAction;

// These imports needed only as a workaround for a JavaDoc bug

import java.lang.Integer;

import java.lang.Long;

import java.lang.Float;

import java.lang.Double;

/**

 * This class provides a skeletal implementation of the {@link Preferences}

 * class, greatly easing the task of implementing it.

 *

 * <p><strong>This class is for {@code Preferences} implementers only.

 * Normal users of the {@code Preferences} facility should have no need to

 * consult this documentation.  The {@link Preferences} documentation

 * should suffice.</strong>

 *

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

 *

 * <p>The SPI methods fall into three groups concerning exception

 * behavior. The {@code 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 {@code removeNodeSpi, keysSpi,

 * childrenNamesSpi, syncSpi} and {@code 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.

 *

 * <p>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

 * {@code 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, subsequently invoking

 * {@code flush()} or {@code sync} would not imply that all previous

 * operations had successfully been made permanent.

 *

 * <p>There is one circumstance under which {@code putSpi, removeSpi and

 * childSpi} <i>should</i> 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.

 *

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

 *

 * <p>Implementation note: In Sun's default {@code 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 {@code Preferences}

 * implementations may have the user identity change from request to request,

 * implicitly passed to {@code Preferences} methods via the use of a

 * static {@link ThreadLocal} instance.  Authors of such implementations are

 * <i>strongly</i> 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 {@code Preferences} instance.  The latter behavior conflicts

 * with normal {@code Preferences} usage and would lead to great confusion.

 *

 * @author  Josh Bloch

 * @see     Preferences

 * @since   1.4

 */

public abstract class AbstractPreferences extends Preferences {

    /**

     * The code point U+0000, assigned to the null control character, is the

     * only character encoded in Unicode and ISO/IEC 10646 that is always

     * invalid in any XML 1.0 and 1.1 document.

     */

    static final int CODE_POINT_U0000 = '\u0000';

    /**

     * Our name relative to parent.

     */

    private final String name;

    /**

     * Our absolute path name.

     */

    private final String absolutePath;

    /**

     * Our parent node.

     */

    final AbstractPreferences parent;

    /**

     * Our root node.

     */

    private final AbstractPreferences root; // Relative to this node

    /**

     * This field should be {@code 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.

     */

    protected boolean newNode = false;

    /**

     * All known unremoved children of this node.  (This "cache" is consulted

     * prior to calling childSpi() or getChild().

     */

    private Map<String, AbstractPreferences> kidCache = new HashMap<>();

    /**

     * This field is used to keep track of whether or not this node has

     * been removed.  Once it's set to true, it will never be reset to false.

     */

    private boolean removed = false;

    /**

     * Registered preference change listeners.

     */

    private PreferenceChangeListener[] prefListeners =

        new PreferenceChangeListener[0];

    /**

     * Registered node change listeners.

     */

    private NodeChangeListener[] nodeListeners = new NodeChangeListener[0];

    /**

     * 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 <i>never</i> locked by a thread that

     * holds a lock on a descendant of that node.

     */

    protected final Object lock = new Object();

    /**

     * Creates a preference node with the specified parent and the specified

     * name relative to its parent.

     *

     * @param parent the parent of this preference node, or null if this

     *               is the root.

     * @param name the name of this preference node, relative to its parent,

     *             or {@code ""} if this is the root.

     * @throws IllegalArgumentException if {@code name} contains a slash

     *          ({@code '/'}),  or {@code parent} is {@code null} and

     *          name isn't {@code ""}.

     */

    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;

    }

    /**

     * Implements the {@code put} method as per the specification in

     * {@link Preferences#put(String,String)}.

     *

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

     *

     * @param key key with which the specified value is to be associated.

     * @param value value to be associated with the specified key.

     * @throws NullPointerException if key or value is {@code null}.

     * @throws IllegalArgumentException if {@code key.length()} exceeds

     *       {@code MAX_KEY_LENGTH} or if {@code value.length} exceeds

     *       {@code MAX_VALUE_LENGTH}.

     * @throws IllegalArgumentException if either key or value contain

     *         the null control character, code point U+0000.

     * @throws IllegalStateException if this node (or an ancestor) has been

     *         removed with the {@link #removeNode()} method.

     */

    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);

        if (key.indexOf(CODE_POINT_U0000) != -1)

            throw new IllegalArgumentException("Key contains code point U+0000");

        if (value.indexOf(CODE_POINT_U0000) != -1)

            throw new IllegalArgumentException("Value contains code point U+0000");

        synchronized(lock) {

            if (removed)

                throw new IllegalStateException("Node has been removed.");

            putSpi(key, value);

            enqueuePreferenceChangeEvent(key, value);

        }

    }

    /**

     * Implements the {@code get} method as per the specification in

     * {@link Preferences#get(String,String)}.

     *

     * <p>This implementation first checks to see if {@code key} is

     * {@code null} throwing a {@code 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 {@code getSpi}

     * invocation returns {@code null} or throws an exception, in which case

     * this invocation returns {@code def}.

     *

     * @param key key whose associated value is to be returned.

     * @param def the value to be returned in the event that this

     *        preference node has no value associated with {@code key}.

     * @return the value associated with {@code key}, or {@code def}

     *         if no value is associated with {@code key}.

     * @throws IllegalStateException if this node (or an ancestor) has been

     *         removed with the {@link #removeNode()} method.

     * @throws NullPointerException if key is {@code null}.  (A

     *         {@code null} default <i>is</i> permitted.)

     * @throws IllegalArgumentException if key contains the null control

     *         character, code point U+0000.

     */

    public String get(String key, String def) {

        if (key==null)

            throw new NullPointerException("Null key");

        if (key.indexOf(CODE_POINT_U0000) != -1)

            throw new IllegalArgumentException("Key contains code point U+0000");

        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 {@code remove(String)} method as per the specification

     * in {@link Preferences#remove(String)}.

     *

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

     *

     * @param key key whose mapping is to be removed from the preference node.

     * @throws IllegalStateException if this node (or an ancestor) has been

     *         removed with the {@link #removeNode()} method.

     * @throws IllegalArgumentException if key contains the null control

     *         character, code point U+0000.

     * @throws NullPointerException {@inheritDoc}.

     */

    public void remove(String key) {

        Objects.requireNonNull(key, "Specified key cannot be null");

        if (key.indexOf(CODE_POINT_U0000) != -1)

            throw new IllegalArgumentException("Key contains code point U+0000");

        synchronized(lock) {

            if (removed)

                throw new IllegalStateException("Node has been removed.");

            removeSpi(key);

            enqueuePreferenceChangeEvent(key, null);

        }

    }

    /**

     * Implements the {@code clear} method as per the specification in

     * {@link Preferences#clear()}.

     *

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

     *

     * @throws BackingStoreException if this operation cannot be completed

     *         due to a failure in the backing store, or inability to

     *         communicate with it.

     * @throws IllegalStateException if this node (or an ancestor) has been

     *         removed with the {@link #removeNode()} method.

     */

    public void clear() throws BackingStoreException {

        synchronized(lock) {

            for (String key : keys())

                remove(key);

        }

    }

    /**

     * Implements the {@code putInt} method as per the specification in

     * {@link Preferences#putInt(String,int)}.

     *

     * <p>This implementation translates {@code value} to a string with

     * {@link Integer#toString(int)} and invokes {@link #put(String,String)}

     * on the result.

     *

     * @param key key with which the string form of value is to be associated.

     * @param value value whose string form is to be associated with key.

     * @throws NullPointerException if key is {@code null}.

     * @throws IllegalArgumentException if {@code key.length()} exceeds

     *         {@code MAX_KEY_LENGTH}.

     * @throws IllegalArgumentException if key contains

     *         the null control character, code point U+0000.

     * @throws IllegalStateException if this node (or an ancestor) has been

     *         removed with the {@link #removeNode()} method.

     */

    public void putInt(String key, int value) {

        put(key, Integer.toString(value));

    }

    /**

     * Implements the {@code getInt} method as per the specification in

     * {@link Preferences#getInt(String,int)}.

     *

     * <p>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 {@code int} with

     * {@link Integer#parseInt(String)}.  If the attempt succeeds, the return

     * value is returned by this method.  Otherwise, {@code def} is returned.

     *

     * @param key key whose associated value is to be returned as an int.

     * @param def the value to be returned in the event that this

     *        preference node has no value associated with {@code key}

     *        or the associated value cannot be interpreted as an int.

     * @return the int value represented by the string associated with

     *         {@code key} in this preference node, or {@code def} if the

     *         associated value does not exist or cannot be interpreted as

     *         an int.

     * @throws IllegalStateException if this node (or an ancestor) has been

     *         removed with the {@link #removeNode()} method.

     * @throws NullPointerException if {@code key} is {@code null}.

     * @throws IllegalArgumentException if key contains the null control

     *         character, code point U+0000.

     */

    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 {@code putLong} method as per the specification in

     * {@link Preferences#putLong(String,long)}.

     *

     * <p>This implementation translates {@code value} to a string with

     * {@link Long#toString(long)} and invokes {@link #put(String,String)}

     * on the result.

     *

     * @param key key with which the string form of value is to be associated.

     * @param value value whose string form is to be associated with key.

     * @throws NullPointerException if key is {@code null}.

     * @throws IllegalArgumentException if {@code key.length()} exceeds

     *         {@code MAX_KEY_LENGTH}.

     * @throws IllegalArgumentException if key contains

     *         the null control character, code point U+0000.

     * @throws IllegalStateException if this node (or an ancestor) has been

     *         removed with the {@link #removeNode()} method.

     */

    public void putLong(String key, long value) {

        put(key, Long.toString(value));

    }

    /**

     * Implements the {@code getLong} method as per the specification in

     * {@link Preferences#getLong(String,long)}.

     *

     * <p>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 {@code long} with

     * {@link Long#parseLong(String)}.  If the attempt succeeds, the return

     * value is returned by this method.  Otherwise, {@code def} is returned.

     *

     * @param key key whose associated value is to be returned as a long.

     * @param def the value to be returned in the event that this

     *        preference node has no value associated with {@code key}

     *        or the associated value cannot be interpreted as a long.

     * @return the long value represented by the string associated with

     *         {@code key} in this preference node, or {@code def} if the

     *         associated value does not exist or cannot be interpreted as

     *         a long.

     * @throws IllegalStateException if this node (or an ancestor) has been

     *         removed with the {@link #removeNode()} method.

     * @throws NullPointerException if {@code key} is {@code null}.

     * @throws IllegalArgumentException if key contains the null control

     *         character, code point U+0000.

     */

    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 {@code putBoolean} method as per the specification in

     * {@link Preferences#putBoolean(String,boolean)}.

     *

     * <p>This implementation translates {@code value} to a string with

     * {@link String#valueOf(boolean)} and invokes {@link #put(String,String)}

     * on the result.

     *

     * @param key key with which the string form of value is to be associated.

     * @param value value whose string form is to be associated with key.

     * @throws NullPointerException if key is {@code null}.

     * @throws IllegalArgumentException if {@code key.length()} exceeds

     *         {@code MAX_KEY_LENGTH}.

     * @throws IllegalArgumentException if key contains

     *         the null control character, code point U+0000.

     * @throws IllegalStateException if this node (or an ancestor) has been

     *         removed with the {@link #removeNode()} method.

     */

    public void putBoolean(String key, boolean value) {

        put(key, String.valueOf(value));

    }

    /**

     * Implements the {@code getBoolean} method as per the specification in

     * {@link Preferences#getBoolean(String,boolean)}.

     *

     * <p>This implementation invokes {@link #get(String,String) get(key,

     * null)}.  If the return value is non-null, it is compared with

     * {@code "true"} using {@link String#equalsIgnoreCase(String)}.  If the

     * comparison returns {@code true}, this invocation returns

     * {@code true}.  Otherwise, the original return value is compared with

     * {@code "false"}, again using {@link String#equalsIgnoreCase(String)}.

     * If the comparison returns {@code true}, this invocation returns

     * {@code false}.  Otherwise, this invocation returns {@code def}.