FileBasedFactory.java, [...]: New files, all merged from classpath.

2003-02-13  Michael Koch  <konqueror@gmx.de>

	* gnu/java/util/prefs/FileBasedFactory.java,
	gnu/java/util/prefs/MemmoryBasedFactory.java,
	gnu/java/util/prefs/MemoryBasedPreferences.java,
	gnu/java/util/prefs/NodeReader.java,
	gnu/java/util/prefs/NodeWriter.java,
	java/util/prefs/AbstractPreferences.java,
	java/util/prefs/BackingStoreException.java,
	java/util/prefs/InvalidPreferencesFormatException.java,
	java/util/prefs/NodeChangeEvent.java,
	java/util/prefs/NodeChangeListener.java,
	java/util/prefs/PreferenceChangeEvent.java,
	java/util/prefs/PreferenceChangeListener.java,
	java/util/prefs/Preferences.java,
	java/util/prefs/PreferencesFactory.java:
	New files, all merged from classpath.
	* Makefile.am
	(ordinary_java_source_files): Added the following files:
	gnu/java/util/prefs/FileBasedFactory.java,
	gnu/java/util/prefs/MemmoryBasedFactory.java,
	gnu/java/util/prefs/MemoryBasedPreferences.java,
	gnu/java/util/prefs/NodeReader.java,
	gnu/java/util/prefs/NodeWriter.java,
	(core_java_source_files): Added the following files:
	java/util/prefs/AbstractPreferences.java,
	java/util/prefs/BackingStoreException.java,
	java/util/prefs/InvalidPreferencesFormatException.java,
	java/util/prefs/NodeChangeEvent.java,
	java/util/prefs/NodeChangeListener.java,
	java/util/prefs/PreferenceChangeEvent.java,
	java/util/prefs/PreferenceChangeListener.java,
	java/util/prefs/Preferences.java,
	java/util/prefs/PreferencesFactory.java
	* Makefile.in: Regenerated.

From-SVN: r62827

5 files changed, 803 insertions, 0 deletions

diff --git a/libjava/gnu/java/util/prefs/FileBasedFactory.java b/libjava/gnu/java/util/prefs/FileBasedFactory.java
new file mode 100644
index 0000000..fc6085f
--- /dev/null
+++ b/libjava/gnu/java/util/prefs/FileBasedFactory.java
@@ -0,0 +1,57 @@
+/* FileBasedFactory - Default Classpath implementation of a PreferencesFactory
+   Copyright (C) 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.util.prefs;
+
+import java.util.prefs.*;
+
+/**
+ * Default Classpath implementation of a PreferencesFactory.
+ * Returns system and user root Preferences nodes that are read from files.
+ *
+ * @author Mark Wielaard (mark@klomp.org)
+ */
+public class FileBasedFactory implements PreferencesFactory {
+
+    public Preferences systemRoot() {
+        return null;
+    }
+
+    public Preferences userRoot() {
+        return null;
+    }
+}
diff --git a/libjava/gnu/java/util/prefs/MemoryBasedFactory.java b/libjava/gnu/java/util/prefs/MemoryBasedFactory.java
new file mode 100644
index 0000000..ff21066
--- /dev/null
+++ b/libjava/gnu/java/util/prefs/MemoryBasedFactory.java
@@ -0,0 +1,64 @@
+/* MemoryBasedFactory - Memory based PreferencesFactory usefull for testing
+   Copyright (C) 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.util.prefs;
+
+import java.util.prefs.*;
+
+/**
+ * Memory based PreferencesFactory usefull for testing.
+ * Returns completely empty Preferences for system and user roots.
+ * All changes are only backed by the current instances in memory.
+ *
+ * @author Mark Wielaard (mark@klomp.org)
+ */
+public class MemoryBasedFactory implements PreferencesFactory {
+
+    // Static fields containing the preferences root nodes
+    private static final Preferences systemPreferences
+        = new MemoryBasedPreferences(null, "", false);
+    private static final Preferences userPreferences
+        = new MemoryBasedPreferences(null, "", true);
+
+    public Preferences systemRoot() {
+        return systemPreferences;
+    }
+
+    public Preferences userRoot() {
+        return userPreferences;
+    }
+}
diff --git a/libjava/gnu/java/util/prefs/MemoryBasedPreferences.java b/libjava/gnu/java/util/prefs/MemoryBasedPreferences.java
new file mode 100644
index 0000000..c1d59c7
--- /dev/null
+++ b/libjava/gnu/java/util/prefs/MemoryBasedPreferences.java
@@ -0,0 +1,144 @@
+/* MemoryBasedPreferences - A Preference node which holds all entries in memory
+   Copyright (C) 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.util.prefs;
+
+import java.util.HashMap;
+
+import java.util.prefs.*;
+
+/**
+ * A Preference node which holds all entries in memory
+ *
+ * @author Mark Wielaard (mark@klomp.org)
+ */
+public class MemoryBasedPreferences extends AbstractPreferences {
+
+    /** True if this is a preference node in the user tree, false otherwise. */
+    private final boolean isUser;
+
+    /** Contains all the preference entries of this node. */
+    private HashMap entries = new HashMap();
+
+    /**
+     * Creates a new preferences node with the given name and parent.
+     * When isUser is true it will be user node otherwise it will be a system
+     * node. It will always set the <code>newNode</code> field to true
+     * since there is no real backing store, so all nodes are new.
+     */
+    public MemoryBasedPreferences(MemoryBasedPreferences parent,
+                                  String name,
+                                  boolean isUser) {
+        super(parent, name);
+        this.isUser = isUser;
+
+        // Since we do not have a real backing store all nodes are new
+        newNode = true;
+    }
+
+    /**
+     * Returns true if this node was created as a user node.
+     */
+    public boolean isUserNode() {
+        return isUser;
+    }
+
+    /**
+     * Returns an empty array since all children names are always already
+     * chached.
+     */
+    protected String[] childrenNamesSpi() throws BackingStoreException {
+        return new String[0];
+    }
+
+    /**
+     * Returns a new node with the given name with as parent this node and
+     * with the <code>isUser</code> flag set to the same value as this node.
+     */
+    protected AbstractPreferences childSpi(String childName) {
+       return new MemoryBasedPreferences(this, childName, isUser);
+    }
+
+    /**
+     * Returns a (possibly empty) array of keys of the preferences entries of
+     * this node.
+     */
+    protected String[] keysSpi() throws BackingStoreException {
+        return (String[]) entries.keySet().toArray(new String[entries.size()]);
+    }
+
+    /**
+     * Returns the associated value from this nodes preferences entries or
+     * null when the key has not been set.
+     */
+    protected String getSpi(String key) {
+        return (String) entries.get(key);
+    }
+
+    /**
+     * Sets the value for the given key.
+     */
+    protected void putSpi(String key, String value) {
+        entries.put(key, value);
+    }
+
+    /**
+     * Removes the entry with the given key.
+     */
+    protected void removeSpi(String key) {
+        entries.remove(key);
+    }
+
+    /**
+     * Does nothing since we do not have any backing store.
+     */
+    protected void flushSpi() {
+    }
+
+    /**
+     * Does nothing since we do not have any backing store.
+     */
+    protected void syncSpi() {
+    }
+
+    /**
+     * Just removes the entries map of this node.
+     */
+    protected void removeNodeSpi() {
+        entries = null;
+    }
+}
diff --git a/libjava/gnu/java/util/prefs/NodeReader.java b/libjava/gnu/java/util/prefs/NodeReader.java
new file mode 100644
index 0000000..6c9fdc9
--- /dev/null
+++ b/libjava/gnu/java/util/prefs/NodeReader.java
@@ -0,0 +1,223 @@
+/* NodeReader - Reads and imports preferences nodes from files
+   Copyright (C) 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.util.prefs;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.InputStream;
+import java.io.IOException;
+import java.io.Reader;
+
+import java.util.prefs.*;
+
+/**
+ * Reads and imports preferences nodes from files.
+ *
+ * @author Mark Wielaard (mark@klomp.org)
+ */
+public class NodeReader {
+
+    private final BufferedReader br;
+    private String line = "";
+
+    private final PreferencesFactory factory;
+
+    public NodeReader(Reader r, PreferencesFactory factory) {
+        if(r instanceof BufferedReader) {
+            br = (BufferedReader) r;
+        } else {
+            br = new BufferedReader(r);
+        }
+        this.factory = factory;
+    }
+
+    public NodeReader(InputStream is, PreferencesFactory factory) {
+        this(new InputStreamReader(is), factory);
+    }
+
+    public void importPreferences()
+                    throws InvalidPreferencesFormatException, IOException
+    {
+        readPreferences();
+    }
+
+    private void readPreferences()
+                    throws InvalidPreferencesFormatException, IOException
+    {
+        // Begin starting tag
+        skipTill("<preferences");
+
+        readRoot();
+
+        // Ending tag
+        skipTill("</preferences>");
+    }
+
+    private void readRoot()
+                    throws InvalidPreferencesFormatException, IOException
+    {
+        // Begin starting tag
+        skipTill("<root");
+
+        // type attribute
+        skipTill("type=\"");
+        String type = readTill("\"");
+        Preferences root;
+        if ("user".equals(type)) {
+            root = factory.userRoot();
+        } else if ("system".equals(type)) {
+            root = factory.systemRoot();
+        } else {
+            throw new InvalidPreferencesFormatException("Unknown type: "
+                                                        + type);
+        }
+
+        // Read root map and subnodes
+        readMap(root);
+        readNodes(root);
+
+        // Ending tag
+        skipTill("</root>");
+    }
+
+    private void readNodes(Preferences node)
+                    throws InvalidPreferencesFormatException, IOException
+    {
+        while ("node".equals(nextTag())) {
+            skipTill("<node");
+            skipTill("name=\"");
+            String name = readTill("\"");
+            Preferences subnode = node.node(name);
+            System.out.println("Found subnode: " + subnode.absolutePath());
+            readMap(subnode);
+            readNodes(subnode);
+            skipTill("</node>");
+        }
+        
+    }
+
+    private void readMap(Preferences node)
+                    throws InvalidPreferencesFormatException, IOException
+    {
+        // Begin map tag
+        skipTill("<map");
+
+        // Empty map?
+        if (line.startsWith("/>")) {
+            line = line.substring(2);
+            return;
+        }
+
+        // Map entries
+        readEntries(node);
+
+        // Ending tag
+        skipTill("</map>");
+    }
+
+    private void readEntries(Preferences node)
+                    throws InvalidPreferencesFormatException, IOException
+    {
+        while ("entry".equals(nextTag())) {
+            skipTill("<entry");
+            skipTill("key=\"");
+            String key = readTill("\"");
+            skipTill("value=\"");
+            String value = readTill("\"");
+            System.out.println("Key: " + key + " Value: " + value);
+            node.put(key, value);
+        }
+    }
+
+    private void skipTill(String s)
+                    throws InvalidPreferencesFormatException, IOException
+    {
+        while(true) {
+            if (line == null)
+                throw new InvalidPreferencesFormatException(s + " not found");
+            
+            int index = line.indexOf(s);
+            if (index == -1)  {
+                line = br.readLine();
+            } else {
+                line = line.substring(index+s.length());
+                return;
+            }
+        }
+    }
+
+    private String readTill(String s)
+                    throws InvalidPreferencesFormatException
+    {
+        int index = line.indexOf(s);
+        if (index == -1)
+                throw new InvalidPreferencesFormatException(s + " not found");
+
+        String read = line.substring(0, index);
+        line = line.substring(index+s.length());
+
+        return read;
+    }
+
+    private String nextTag()
+                    throws InvalidPreferencesFormatException, IOException
+    {
+        while(true) {
+            if (line == null)
+                throw new InvalidPreferencesFormatException("unexpected EOF");
+            
+            int start = line.indexOf("<");
+            if (start == -1)  {
+                line = br.readLine();
+            } else {
+                // Find end of tag
+                int end = start+1;
+                while (end != line.length()
+                       && " \t\r\n".indexOf(line.charAt(end)) == -1) {
+                    end++;
+                }
+                // Line now starts at the found tag
+                String tag = line.substring(start+1,end);
+                line = line.substring(start);
+                return tag;
+            }
+        }
+    }
+
+}
diff --git a/libjava/gnu/java/util/prefs/NodeWriter.java b/libjava/gnu/java/util/prefs/NodeWriter.java
new file mode 100644
index 0000000..d570d99
--- /dev/null
+++ b/libjava/gnu/java/util/prefs/NodeWriter.java
@@ -0,0 +1,315 @@
+/* NodeWriter - Writes and exports preferences nodes to files
+   Copyright (C) 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.util.prefs;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+
+import java.util.StringTokenizer;
+
+import java.util.prefs.*;
+
+/**
+ * Writes and exports preferences nodes to files
+ *
+ * @author Mark Wielaard (mark@klomp.org)
+ */
+public class NodeWriter {
+
+    /** The Preferences node to write. */
+    private final Preferences prefs;
+
+    /** The bufferedWriter to write the node to. */
+    private final BufferedWriter bw;
+
+    /**
+     * True if the complete sub tree should be written,
+     * false if only the node should be written.
+     */
+    private boolean subtree;
+
+    /**
+     * Creates a new NodeWriter for the given preferences node and writer.
+     */
+    public NodeWriter(Preferences prefs, Writer w) {
+        this.prefs = prefs;
+        if (w instanceof BufferedWriter) {
+            this.bw = (BufferedWriter) w;
+        } else {
+            this.bw = new BufferedWriter(w);
+        }
+    }
+
+    /**
+     * Creates a new NodeWriter for the given preferences node and
+     * outputstream. Creates a new OutputStreamWriter.
+     */
+    public NodeWriter(Preferences prefs, OutputStream os) {
+        this(prefs, new OutputStreamWriter(os));
+    }
+
+    /**
+     * Writes the preference node plus the complete subtree.
+     */
+    public void writePrefsTree() throws BackingStoreException, IOException {
+        subtree = true;
+        writeHeader();
+        writePreferences();
+        bw.flush();
+    }
+
+    /**
+     * Writes only the preference node.
+     */
+    public void writePrefs() throws BackingStoreException, IOException {
+        subtree = false;
+        writeHeader();
+        writePreferences();
+        bw.flush();
+    }
+
+    /**
+     * Writes the standard header.
+     */
+    private void writeHeader() throws BackingStoreException, IOException {
+        bw.write("<?xml version=\"1.0\"?>");
+        bw.newLine();
+        bw.newLine();
+        bw.write("<!-- GNU Classpath java.util.prefs Preferences ");
+
+        if (prefs.isUserNode()) {
+            bw.write("user");
+        } else {
+            bw.write("system");
+        }
+
+        // root node?
+        if (prefs.parent() == null) {
+            bw.write(" root");
+        }
+
+        if (subtree) {
+            bw.write(" tree");
+        } else {
+            bw.write(" node");
+        }
+
+        // no root?
+        if (prefs.parent() != null) {
+            bw.newLine();
+            bw.write("     '");
+            bw.write(prefs.absolutePath());
+            bw.write('\'');
+            bw.newLine();
+        }
+        bw.write(" -->");
+        bw.newLine();
+        bw.newLine();
+    }
+
+    /**
+     * Write the preferences tag and the root.
+     */
+    private void writePreferences() throws BackingStoreException, IOException {
+        bw.write("<preferences>");
+        bw.newLine();
+        writeRoot();
+        bw.write("</preferences>");
+        bw.newLine();
+    }
+
+    private void writeRoot() throws BackingStoreException, IOException {
+        bw.write("  <root type=\"");
+        if (prefs.isUserNode()) {
+            bw.write("user");
+        } else {
+            bw.write("system");
+        }
+        bw.write("\"/>");
+
+        writeRootMap();
+        writeNode();
+
+        bw.write("  </root>");
+        bw.newLine();
+    }
+
+    private void writeRootMap() throws BackingStoreException, IOException {
+        // Is it a root node?
+        if(prefs.parent() == null && prefs.keys().length > 0) {
+            bw.newLine();
+            writeMap(prefs, 2);
+        } else {
+            bw.write("<map/>");
+            bw.newLine();
+        }
+    }
+
+    /**
+     * Writes all the parents of the preferences node without any entries.
+     * Returns the number of parents written, which has to be used as
+     * argument to <code>writeCloseParents()</code> after writing the node
+     * itself.
+     */
+    private int writeParents() throws IOException {
+        int parents;
+        String path = prefs.absolutePath();
+        int lastslash = path.lastIndexOf("/");
+        if (lastslash > 0) {
+            path = path.substring(1, lastslash);
+            StringTokenizer st = new StringTokenizer(path);
+            parents = st.countTokens();
+
+            System.out.println("path: " + path);
+            System.out.println("parents: " + parents);
+
+            for (int i=0; i<parents; i++) {
+                String name = st.nextToken();
+                indent(i+2);
+                bw.write("<node name=\"" + name + "\">");
+                bw.write("<map/>");
+                bw.write("</node>");
+                bw.newLine();
+            }
+        } else {
+            parents = 0;
+        }
+
+        return parents;
+    }
+
+    private void writeCloseParents(int parents) throws IOException {
+        while(parents > 0) {
+            indent(parents+1);
+            bw.write("</node>");
+            bw.newLine();
+            parents--;
+        }
+    }
+
+    private void writeNode() throws BackingStoreException, IOException {
+        int parents = writeParents();
+        // root?
+        int indent;
+        if (prefs.parent() == null) {
+            indent = parents+1;
+        } else {
+            indent = parents+2;
+        }
+        writeNode(prefs, indent);
+        writeCloseParents(parents);
+    }
+
+    private void writeNode(Preferences node, int indent)
+                                    throws BackingStoreException, IOException
+    {
+        // not root?
+        if (node.parent() != null) {
+            indent(indent);
+            bw.write("<node name=\"" + node.name() + "\">");
+            if (node.keys().length > 0) {
+                bw.newLine();
+            }
+            writeMap(node, indent+1);
+        }
+
+        if (subtree) {
+            String[] children = node.childrenNames();
+            for (int i=0; i<children.length; i++) {
+                Preferences child = node.node(children[i]);
+                writeNode(child, indent+1);
+            }
+        }
+
+        // not root?
+        if (node.parent() != null) {
+            indent(indent);
+            bw.write("</node>");
+            bw.newLine();
+        }
+    }
+
+    private void writeMap(Preferences node, int indent) 
+                                    throws BackingStoreException, IOException
+    {
+        // construct String used for indentation
+        StringBuffer indentBuffer = new StringBuffer(2*indent);
+        for (int i=0; i < indent; i++)
+            indentBuffer.append("  ");
+        String indentString = indentBuffer.toString();
+
+        if (node.keys().length > 0) {
+            bw.write(indentString);
+            bw.write("<map>");
+            bw.newLine();
+            writeEntries(node, indentString + "  ");
+            bw.write(indentString);
+            bw.write("</map>");
+        } else {
+            bw.write("<map/>");
+        }
+        bw.newLine();
+    }
+
+    private void writeEntries(Preferences node, String indent)
+                                    throws BackingStoreException, IOException
+    {
+        String[] keys = node.keys();
+        for(int i = 0; i < keys.length; i++) {
+            String value = node.get(keys[i], null);
+            if (value == null) {
+                throw new BackingStoreException("null value for key '"
+                                                + keys[i] + "'");
+            }
+
+            bw.write(indent);
+            bw.write("<entry key=\"" + keys[i] + "\""
+                    + " value=\"" + value + "\"/>");
+            bw.newLine();
+        }
+    }
+
+    private void indent(int x) throws IOException {
+        for (int i=0; i<x; i++) {
+            bw.write("  ");
+        }
+    }
+}