[kaffe] CVS kaffe (robilad): resynced with gnu classpath: abstract preference fix
Kaffe CVS
cvs-commits at kaffe.org
Wed May 18 15:53:51 PDT 2005
PatchSet 6553
Date: 2005/05/18 22:26:51
Author: robilad
Branch: HEAD
Tag: (none)
Log:
resynced with gnu classpath: abstract preference fix
2005-05-18 Dalibor Topic <robilad at kaffe.org>
Resynced with GNU Classpath.
2005-05-18 Roman Kennke <roman at kennke.org>
* java/util/prefs/AbstractPreferences.java
(flushNode): Changed toArray() call to toArray(new String[0]) call
to avoid casting errors.
Members:
ChangeLog:1.4079->1.4080
libraries/javalib/java/util/prefs/AbstractPreferences.java:INITIAL->1.9
Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.4079 kaffe/ChangeLog:1.4080
--- kaffe/ChangeLog:1.4079 Wed May 18 22:24:39 2005
+++ kaffe/ChangeLog Wed May 18 22:26:51 2005
@@ -2,6 +2,16 @@
Resynced with GNU Classpath.
+ 2005-05-18 Roman Kennke <roman at kennke.org>
+
+ * java/util/prefs/AbstractPreferences.java
+ (flushNode): Changed toArray() call to toArray(new String[0]) call
+ to avoid casting errors.
+
+2005-05-18 Dalibor Topic <robilad at kaffe.org>
+
+ Resynced with GNU Classpath.
+
2005-05-18 Sven de Marothy <sven at physto.se>
* java/text/SimpleDateFormat.java
===================================================================
Checking out kaffe/libraries/javalib/java/util/prefs/AbstractPreferences.java
RCS: /home/cvs/kaffe/kaffe/libraries/javalib/java/util/prefs/AbstractPreferences.java,v
VERS: 1.9
***************
--- /dev/null Sun Aug 4 19:57:58 2002
+++ kaffe/libraries/javalib/java/util/prefs/AbstractPreferences.java Wed May 18 22:53:51 2005
@@ -0,0 +1,1272 @@
+/* AbstractPreferences -- Partial implementation of a Preference node
+ Copyright (C) 2001, 2003, 2004 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 java.util.prefs;
+
+import gnu.java.util.prefs.NodeWriter;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.TreeSet;
+
+/**
+ * Partial implementation of a Preference node.
+ *
+ * @since 1.4
+ * @author Mark Wielaard (mark at klomp.org)
+ */
+public abstract class AbstractPreferences extends Preferences {
+
+ // protected fields
+
+ /**
+ * Object used to lock this preference node. Any thread only locks nodes
+ * downwards when it has the lock on the current node. No method should
+ * synchronize on the lock of any of its parent nodes while holding the
+ * lock on the current node.
+ */
+ protected final Object lock = new Object();
+
+ /**
+ * Set to true in the contructor if the node did not exist in the backing
+ * store when this preference node object was created. Should be set in
+ * the contructor of a subclass. Defaults to false. Used to fire node
+ * changed events.
+ */
+ protected boolean newNode = false;
+
+ // private fields
+
+ /**
+ * The parent preferences node or null when this is the root node.
+ */
+ private final AbstractPreferences parent;
+
+ /**
+ * The name of this node.
+ * Only when this is a root node (parent == null) the name is empty.
+ * It has a maximum of 80 characters and cannot contain any '/' characters.
+ */
+ private final String name;
+
+ /** True when this node has been remove, false otherwise. */
+ private boolean removed = false;
+
+ /**
+ * Holds all the child names and nodes of this node that have been
+ * accessed by earlier <code>getChild()</code> or <code>childSpi()</code>
+ * invocations and that have not been removed.
+ */
+ private HashMap childCache = new HashMap();
+
+ // constructor
+
+ /**
+ * Creates a new AbstractPreferences node with the given parent and name.
+ *
+ * @param parent the parent of this node or null when this is the root node
+ * @param name the name of this node, can not be null, only 80 characters
+ * maximum, must be empty when parent is null and cannot
+ * contain any '/' characters
+ * @exception IllegalArgumentException when name is null, greater then 80
+ * characters, not the empty string but parent is null or
+ * contains a '/' character
+ */
+ protected AbstractPreferences(AbstractPreferences parent, String name) {
+ if ( (name == null) // name should be given
+ || (name.length() > MAX_NAME_LENGTH) // 80 characters max
+ || (parent == null && name.length() != 0) // root has no name
+ || (parent != null && name.length() == 0) // all other nodes do
+ || (name.indexOf('/') != -1)) // must not contain '/'
+ throw new IllegalArgumentException("Illegal name argument '"
+ + name
+ + "' (parent is "
+ + (parent == null ? "" : "not ")
+ + "null)");
+ this.parent = parent;
+ this.name = name;
+ }
+
+ // identification methods
+
+ /**
+ * Returns the absolute path name of this preference node.
+ * The absolute path name of a node is the path name of its parent node
+ * plus a '/' plus its own name. If the node is the root node and has no
+ * parent then its path name is "" and its absolute path name is "/".
+ */
+ public String absolutePath() {
+ if (parent == null)
+ return "/";
+ else
+ return parent.path() + '/' + name;
+ }
+
+ /**
+ * Private helper method for absolutePath. Returns the empty string for a
+ * root node and otherwise the parentPath of its parent plus a '/'.
+ */
+ private String path() {
+ if (parent == null)
+ return "";
+ else
+ return parent.path() + '/' + name;
+ }
+
+ /**
+ * Returns true if this node comes from the user preferences tree, false
+ * if it comes from the system preferences tree.
+ */
+ public boolean isUserNode() {
+ AbstractPreferences root = this;
+ while (root.parent != null)
+ root = root.parent;
+ return root == Preferences.userRoot();
+ }
+
+ /**
+ * Returns the name of this preferences node. The name of the node cannot
+ * be null, can be mostly 80 characters and cannot contain any '/'
+ * characters. The root node has as name "".
+ */
+ public String name() {
+ return name;
+ }
+
+ /**
+ * Returns the String given by
+ * <code>
+ * (isUserNode() ? "User":"System") + " Preference Node: " + absolutePath()
+ * </code>
+ */
+ public String toString() {
+ return (isUserNode() ? "User":"System")
+ + " Preference Node: "
+ + absolutePath();
+ }
+
+ /**
+ * Returns all known unremoved children of this node.
+ *
+ * @return All known unremoved children of this node
+ */
+ protected final AbstractPreferences[] cachedChildren()
+ {
+ return (AbstractPreferences[]) childCache.values().toArray();
+ }
+
+ /**
+ * Returns all the direct sub nodes of this preferences node.
+ * Needs access to the backing store to give a meaningfull answer.
+ * <p>
+ * This implementation locks this node, checks if the node has not yet
+ * been removed and throws an <code>IllegalStateException</code> when it
+ * has been. Then it creates a new <code>TreeSet</code> and adds any
+ * already cached child nodes names. To get any uncached names it calls
+ * <code>childrenNamesSpi()</code> and adds the result to the set. Finally
+ * it calls <code>toArray()</code> on the created set. When the call to
+ * <code>childrenNamesSpi</code> thows an <code>BackingStoreException</code>
+ * this method will not catch that exception but propagate the exception
+ * to the caller.
+ *
+ * @exception BackingStoreException when the backing store cannot be
+ * reached
+ * @exception IllegalStateException when this node has been removed
+ */
+ public String[] childrenNames() throws BackingStoreException {
+ synchronized(lock) {
+ if (isRemoved())
+ throw new IllegalStateException("Node removed");
+
+ TreeSet childrenNames = new TreeSet();
+
+ // First get all cached node names
+ childrenNames.addAll(childCache.keySet());
+
+ // Then add any others
+ String names[] = childrenNamesSpi();
+ for (int i = 0; i < names.length; i++) {
+ childrenNames.add(names[i]);
+ }
+
+ // And return the array of names
+ String[] children = new String[childrenNames.size()];
+ childrenNames.toArray(children);
+ return children;
+
+ }
+ }
+
+ /**
+ * Returns a sub node of this preferences node if the given path is
+ * relative (does not start with a '/') or a sub node of the root
+ * if the path is absolute (does start with a '/').
+ * <p>
+ * This method first locks this node and checks if the node has not been
+ * removed, if it has been removed it throws an exception. Then if the
+ * path is relative (does not start with a '/') it checks if the path is
+ * legal (does not end with a '/' and has no consecutive '/' characters).
+ * Then it recursively gets a name from the path, gets the child node
+ * from the child-cache of this node or calls the <code>childSpi()</code>
+ * method to create a new child sub node. This is done recursively on the
+ * newly created sub node with the rest of the path till the path is empty.
+ * If the path is absolute (starts with a '/') the lock on this node is
+ * droped and this method is called on the root of the preferences tree
+ * with as argument the complete path minus the first '/'.
+ *
+ * @exception IllegalStateException if this node has been removed
+ * @exception IllegalArgumentException if the path contains two or more
+ * consecutive '/' characters, ends with a '/' charactor and is not the
+ * string "/" (indicating the root node) or any name on the path is more
+ * then 80 characters long
+ */
+ public Preferences node(String path) {
+ synchronized(lock) {
+ if (isRemoved())
+ throw new IllegalStateException("Node removed");
+
+ // Is it a relative path?
+ if (!path.startsWith("/")) {
+
+ // Check if it is a valid path
+ if (path.indexOf("//") != -1 || path.endsWith("/"))
+ throw new IllegalArgumentException(path);
+
+ return getNode(path);
+ }
+ }
+
+ // path started with a '/' so it is absolute
+ // we drop the lock and start from the root (omitting the first '/')
+ Preferences root = isUserNode() ? userRoot() : systemRoot();
+ return root.node(path.substring(1));
+
+ }
+
+ /**
+ * Private helper method for <code>node()</code>. Called with this node
+ * locked. Returns this node when path is the empty string, if it is not
+ * empty the next node name is taken from the path (all chars till the
+ * next '/' or end of path string) and the node is either taken from the
+ * child-cache of this node or the <code>childSpi()</code> method is called
+ * on this node with the name as argument. Then this method is called
+ * recursively on the just constructed child node with the rest of the
+ * path.
+ *
+ * @param path should not end with a '/' character and should not contain
+ * consecutive '/' characters
+ * @exception IllegalArgumentException if path begins with a name that is
+ * larger then 80 characters.
+ */
+ private Preferences getNode(String path) {
+ // if mark is dom then goto end
+
+ // Empty String "" indicates this node
+ if (path.length() == 0)
+ return this;
+
+ // Calculate child name and rest of path
+ String childName;
+ String childPath;
+ int nextSlash = path.indexOf('/');
+ if (nextSlash == -1) {
+ childName = path;
+ childPath = "";
+ } else {
+ childName = path.substring(0, nextSlash);
+ childPath = path.substring(nextSlash+1);
+ }
+
+ // Get the child node
+ AbstractPreferences child;
+ child = (AbstractPreferences)childCache.get(childName);
+ if (child == null) {
+
+ if (childName.length() > MAX_NAME_LENGTH)
+ throw new IllegalArgumentException(childName);
+
+ // Not in childCache yet so create a new sub node
+ child = childSpi(childName);
+ // XXX - check if node is new
+ childCache.put(childName, child);
+ }
+
+ // Lock the child and go down
+ synchronized(child.lock) {
+ return child.getNode(childPath);
+ }
+ }
+
+ /**
+ * Returns true if the node that the path points to exists in memory or
+ * in the backing store. Otherwise it returns false or an exception is
+ * thrown. When this node is removed the only valid parameter is the
+ * empty string (indicating this node), the return value in that case
+ * will be false.
+ *
+ * @exception BackingStoreException when the backing store cannot be
+ * reached
+ * @exception IllegalStateException if this node has been removed
+ * and the path is not the empty string (indicating this node)
+ * @exception IllegalArgumentException if the path contains two or more
+ * consecutive '/' characters, ends with a '/' charactor and is not the
+ * string "/" (indicating the root node) or any name on the path is more
+ * then 80 characters long
+ */
+ public boolean nodeExists(String path) throws BackingStoreException {
+ synchronized(lock) {
+ if (isRemoved() && path.length() != 0)
+ throw new IllegalStateException("Node removed");
+
+ // Is it a relative path?
+ if (!path.startsWith("/")) {
+
+ // Check if it is a valid path
+ if (path.indexOf("//") != -1 || path.endsWith("/"))
+ throw new IllegalArgumentException(path);
+
+ return existsNode(path);
+ }
+ }
+
+ // path started with a '/' so it is absolute
+ // we drop the lock and start from the root (omitting the first '/')
+ Preferences root = isUserNode() ? userRoot() : systemRoot();
+ return root.nodeExists(path.substring(1));
+
+ }
+
+ private boolean existsNode(String path) throws BackingStoreException {
+
+ // Empty String "" indicates this node
+ if (path.length() == 0)
+ return(!isRemoved());
+
+ // Calculate child name and rest of path
+ String childName;
+ String childPath;
+ int nextSlash = path.indexOf('/');
+ if (nextSlash == -1) {
+ childName = path;
+ childPath = "";
+ } else {
+ childName = path.substring(0, nextSlash);
+ childPath = path.substring(nextSlash+1);
+ }
+
+ // Get the child node
+ AbstractPreferences child;
+ child = (AbstractPreferences)childCache.get(childName);
+ if (child == null) {
+
+ if (childName.length() > MAX_NAME_LENGTH)
+ throw new IllegalArgumentException(childName);
+
+ // Not in childCache yet so create a new sub node
+ child = getChild(childName);
+
+ if (child == null)
+ return false;
+
+ childCache.put(childName, child);
+ }
+
+ // Lock the child and go down
+ synchronized(child.lock) {
+ return child.existsNode(childPath);
+ }
+ }
+
+ /**
+ * Returns the child sub node if it exists in the backing store or null
+ * if it does not exist. Called (indirectly) by <code>nodeExists()</code>
+ * when a child node name can not be found in the cache.
+ * <p>
+ * Gets the lock on this node, calls <code>childrenNamesSpi()</code> to
+ * get an array of all (possibly uncached) children and compares the
+ * given name with the names in the array. If the name is found in the
+ * array <code>childSpi()</code> is called to get an instance, otherwise
+ * null is returned.
+ *
+ * @exception BackingStoreException when the backing store cannot be
+ * reached
+ */
+ protected AbstractPreferences getChild(String name)
+ throws BackingStoreException
+ {
+ synchronized(lock) {
+ // Get all the names (not yet in the cache)
+ String[] names = childrenNamesSpi();
+ for (int i=0; i < names.length; i++)
+ if (name.equals(names[i]))
+ return childSpi(name);
+
+ // No child with that name found
+ return null;
+ }
+ }
+
+ /**
+ * Returns true if this node has been removed with the
+ * <code>removeNode()</code> method, false otherwise.
+ * <p>
+ * Gets the lock on this node and then returns a boolean field set by
+ * <code>removeNode</code> methods.
+ */
+ protected boolean isRemoved() {
+ synchronized(lock) {
+ return removed;
+ }
+ }
+
+ /**
+ * Returns the parent preferences node of this node or null if this is
+ * the root of the preferences tree.
+ * <p>
+ * Gets the lock on this node, checks that the node has not been removed
+ * and returns the parent given to the constructor.
+ *
+ * @exception IllegalStateException if this node has been removed
+ */
+ public Preferences parent() {
+ synchronized(lock) {
+ if (isRemoved())
+ throw new IllegalStateException("Node removed");
+
+ return parent;
+ }
+ }
+
+ // export methods
+
+ /**
+ * XXX
+ */
+ public void exportNode(OutputStream os)
+ throws BackingStoreException,
+ IOException
+ {
+ NodeWriter nodeWriter = new NodeWriter(this, os);
+ nodeWriter.writePrefs();
+ }
+
+ /**
+ * XXX
+ */
+ public void exportSubtree(OutputStream os)
+ throws BackingStoreException,
+ IOException
+ {
+ NodeWriter nodeWriter = new NodeWriter(this, os);
+ nodeWriter.writePrefsTree();
+ }
+
+ // preference entry manipulation methods
+
+ /**
+ * Returns an (possibly empty) array with all the keys of the preference
+ * entries of this node.
+ * <p>
+ * This method locks this node and checks if the node has not been
+ * removed, if it has been removed it throws an exception, then it returns
+ * the result of calling <code>keysSpi()</code>.
+ *
+ * @exception BackingStoreException when the backing store cannot be
+ * reached
+ * @exception IllegalStateException if this node has been removed
+ */
+ public String[] keys() throws BackingStoreException {
+ synchronized(lock) {
+ if (isRemoved())
+ throw new IllegalStateException("Node removed");
+
+ return keysSpi();
+ }
+ }
+
+
+ /**
+ * Returns the value associated with the key in this preferences node. If
+ * the default value of the key cannot be found in the preferences node
+ * entries or something goes wrong with the backing store the supplied
+ * default value is returned.
+ * <p>
+ * Checks that key is not null and not larger then 80 characters,
+ * locks this node, and checks that the node has not been removed.
+ * Then it calls <code>keySpi()</code> and returns
+ * the result of that method or the given default value if it returned
+ * null or throwed an exception.
+ *
+ * @exception IllegalArgumentException if key is larger then 80 characters
+ * @exception IllegalStateException if this node has been removed
+ * @exception NullPointerException if key is null
+ */
+ public String get(String key, String defaultVal) {
+ if (key.length() > MAX_KEY_LENGTH)
+ throw new IllegalArgumentException(key);
+
+ synchronized(lock) {
+ if (isRemoved())
+ throw new IllegalStateException("Node removed");
+
+ String value;
+ try {
+ value = getSpi(key);
+ } catch (ThreadDeath death) {
+ throw death;
+ } catch (Throwable t) {
+ value = null;
+ }
+
+ if (value != null) {
+ return value;
+ } else {
+ return defaultVal;
+ }
+ }
+ }
+
+ /**
+ * Convenience method for getting the given entry as a boolean.
+ * When the string representation of the requested entry is either
+ * "true" or "false" (ignoring case) then that value is returned,
+ * otherwise the given default boolean value is returned.
+ *
+ * @exception IllegalArgumentException if key is larger then 80 characters
+ * @exception IllegalStateException if this node has been removed
+ * @exception NullPointerException if key is null
+ */
+ public boolean getBoolean(String key, boolean defaultVal) {
+ String value = get(key, null);
+
+ if ("true".equalsIgnoreCase(value))
+ return true;
+
+ if ("false".equalsIgnoreCase(value))
+ return false;
+
+ return defaultVal;
+ }
+
+ /**
+ * Convenience method for getting the given entry as a byte array.
+ * When the string representation of the requested entry is a valid
+ * Base64 encoded string (without any other characters, such as newlines)
+ * then the decoded Base64 string is returned as byte array,
+ * otherwise the given default byte array value is returned.
+ *
+ * @exception IllegalArgumentException if key is larger then 80 characters
+ * @exception IllegalStateException if this node has been removed
+ * @exception NullPointerException if key is null
+ */
+ public byte[] getByteArray(String key, byte[] defaultVal) {
+ String value = get(key, null);
+
+ byte[] b = null;
+ if (value != null) {
+ b = decode64(value);
+ }
+
+ if (b != null)
+ return b;
+ else
+ return defaultVal;
+ }
+
+ /**
+ * Helper method for decoding a Base64 string as an byte array.
+ * Returns null on encoding error. This method does not allow any other
+ * characters present in the string then the 65 special base64 chars.
+ */
+ private static byte[] decode64(String s) {
+ ByteArrayOutputStream bs = new ByteArrayOutputStream((s.length()/4)*3);
+ char[] c = new char[s.length()];
+ s.getChars(0, s.length(), c, 0);
+
+ // Convert from base64 chars
+ int endchar = -1;
+ for(int j = 0; j < c.length && endchar == -1; j++) {
+ if (c[j] >= 'A' && c[j] <= 'Z') {
+ c[j] -= 'A';
+ } else if (c[j] >= 'a' && c[j] <= 'z') {
+ c[j] = (char) (c[j] + 26 - 'a');
+ } else if (c[j] >= '0' && c[j] <= '9') {
+ c[j] = (char) (c[j] + 52 - '0');
+ } else if (c[j] == '+') {
+ c[j] = 62;
+ } else if (c[j] == '/') {
+ c[j] = 63;
+ } else if (c[j] == '=') {
+ endchar = j;
+ } else {
+ return null; // encoding exception
+ }
+ }
+
+ int remaining = endchar == -1 ? c.length : endchar;
+ int i = 0;
+ while (remaining > 0) {
+ // Four input chars (6 bits) are decoded as three bytes as
+ // 000000 001111 111122 222222
+
+ byte b0 = (byte) (c[i] << 2);
+ if (remaining >= 2) {
+ b0 += (c[i+1] & 0x30) >> 4;
+ }
+ bs.write(b0);
+
+ if (remaining >= 3) {
+ byte b1 = (byte) ((c[i+1] & 0x0F) << 4);
+ b1 += (byte) ((c[i+2] & 0x3C) >> 2);
+ bs.write(b1);
+ }
+
+ if (remaining >= 4) {
+ byte b2 = (byte) ((c[i+2] & 0x03) << 6);
+ b2 += c[i+3];
+ bs.write(b2);
+ }
+
+ i += 4;
+ remaining -= 4;
+ }
+
+ return bs.toByteArray();
+ }
+
+ /**
+ * Convenience method for getting the given entry as a double.
+ * When the string representation of the requested entry can be decoded
+ * with <code>Double.parseDouble()</code> then that double is returned,
+ * otherwise the given default double value is returned.
+ *
+ * @exception IllegalArgumentException if key is larger then 80 characters
+ * @exception IllegalStateException if this node has been removed
+ * @exception NullPointerException if key is null
+ */
+ public double getDouble(String key, double defaultVal) {
+ String value = get(key, null);
+
+ if (value != null) {
+ try {
+ return Double.parseDouble(value);
+ } catch (NumberFormatException nfe) { /* ignore */ }
+ }
+
+ return defaultVal;
+ }
+
+ /**
+ * Convenience method for getting the given entry as a float.
+ * When the string representation of the requested entry can be decoded
+ * with <code>Float.parseFloat()</code> then that float is returned,
+ * otherwise the given default float value is returned.
+ *
+ * @exception IllegalArgumentException if key is larger then 80 characters
+ * @exception IllegalStateException if this node has been removed
+ * @exception NullPointerException if key is null
+ */
+ public float getFloat(String key, float defaultVal) {
+ String value = get(key, null);
+
+ if (value != null) {
+ try {
+ return Float.parseFloat(value);
+ } catch (NumberFormatException nfe) { /* ignore */ }
+ }
+
+ return defaultVal;
+ }
+
+ /**
+ * Convenience method for getting the given entry as an integer.
+ * When the string representation of the requested entry can be decoded
+ * with <code>Integer.parseInt()</code> then that integer is returned,
+ * otherwise the given default integer value is returned.
+ *
+ * @exception IllegalArgumentException if key is larger then 80 characters
+ * @exception IllegalStateException if this node has been removed
+ * @exception NullPointerException if key is null
+ */
+ public int getInt(String key, int defaultVal) {
+ String value = get(key, null);
+
+ if (value != null) {
+ try {
+ return Integer.parseInt(value);
+ } catch (NumberFormatException nfe) { /* ignore */ }
+ }
+
+ return defaultVal;
+ }
+
+ /**
+ * Convenience method for getting the given entry as a long.
+ * When the string representation of the requested entry can be decoded
+ * with <code>Long.parseLong()</code> then that long is returned,
+ * otherwise the given default long value is returned.
+ *
+ * @exception IllegalArgumentException if key is larger then 80 characters
+ * @exception IllegalStateException if this node has been removed
+ * @exception NullPointerException if key is null
+ */
+ public long getLong(String key, long defaultVal) {
+ String value = get(key, null);
+
+ if (value != null) {
+ try {
+ return Long.parseLong(value);
+ } catch (NumberFormatException nfe) { /* ignore */ }
+ }
+
+ return defaultVal;
+ }
+
+ /**
+ * Sets the value of the given preferences entry for this node.
+ * Key and value cannot be null, the key cannot exceed 80 characters
+ * and the value cannot exceed 8192 characters.
+ * <p>
+ * The result will be immediatly visible in this VM, but may not be
+ * immediatly written to the backing store.
+ * <p>
+ * Checks that key and value are valid, locks this node, and checks that
+ * the node has not been removed. Then it calls <code>putSpi()</code>.
+ *
+ * @exception NullPointerException if either key or value are null
+ * @exception IllegalArgumentException if either key or value are to large
+ * @exception IllegalStateException when this node has been removed
+ */
+ public void put(String key, String value) {
+ if (key.length() > MAX_KEY_LENGTH
+ || value.length() > MAX_VALUE_LENGTH)
+ throw new IllegalArgumentException("key ("
+ + key.length() + ")"
+ + " or value ("
+ + value.length() + ")"
+ + " to large");
+ synchronized(lock) {
+ if (isRemoved())
+ throw new IllegalStateException("Node removed");
+
+ putSpi(key, value);
+
+ // XXX - fire events
+ }
+
+ }
+
+ /**
+ * Convenience method for setting the given entry as a boolean.
+ * The boolean is converted with <code>Boolean.toString(value)</code>
+ * and then stored in the preference entry as that string.
+ *
+ * @exception NullPointerException if key is null
+ * @exception IllegalArgumentException if the key length is to large
+ * @exception IllegalStateException when this node has been removed
+ */
+ public void putBoolean(String key, boolean value) {
+ put(key, String.valueOf(value));
+ // XXX - Use when using 1.4 compatible Boolean
+ // put(key, Boolean.toString(value));
+ }
+
+ /**
+ * Convenience method for setting the given entry as an array of bytes.
+ * The byte array is converted to a Base64 encoded string
+ * and then stored in the preference entry as that string.
+ * <p>
+ * Note that a byte array encoded as a Base64 string will be about 1.3
+ * times larger then the original length of the byte array, which means
+ * that the byte array may not be larger about 6 KB.
+ *
+ * @exception NullPointerException if either key or value are null
+ * @exception IllegalArgumentException if either key or value are to large
+ * @exception IllegalStateException when this node has been removed
+ */
+ public void putByteArray(String key, byte[] value) {
+ put(key, encode64(value));
+ }
+
+ /**
+ * Helper method for encoding an array of bytes as a Base64 String.
+ */
+ private static String encode64(byte[] b) {
+ StringBuffer sb = new StringBuffer((b.length/3)*4);
+
+ int i = 0;
+ int remaining = b.length;
+ char c[] = new char[4];
+ while (remaining > 0) {
+ // Three input bytes are encoded as four chars (6 bits) as
+ // 00000011 11112222 22333333
+
+ c[0] = (char) ((b[i] & 0xFC) >> 2);
+ c[1] = (char) ((b[i] & 0x03) << 4);
+ if (remaining >= 2) {
+ c[1] += (char) ((b[i+1] & 0xF0) >> 4);
+ c[2] = (char) ((b[i+1] & 0x0F) << 2);
+ if (remaining >= 3) {
+ c[2] += (char) ((b[i+2] & 0xC0) >> 6);
+ c[3] = (char) (b[i+2] & 0x3F);
+ } else {
+ c[3] = 64;
+ }
+ } else {
+ c[2] = 64;
+ c[3] = 64;
+ }
+
+ // Convert to base64 chars
+ for(int j = 0; j < 4; j++) {
+ if (c[j] < 26) {
+ c[j] += 'A';
+ } else if (c[j] < 52) {
+ c[j] = (char) (c[j] - 26 + 'a');
+ } else if (c[j] < 62) {
+ c[j] = (char) (c[j] - 52 + '0');
+ } else if (c[j] == 62) {
+ c[j] = '+';
+ } else if (c[j] == 63) {
+ c[j] = '/';
+ } else {
+ c[j] = '=';
+ }
+ }
+
+ sb.append(c);
+ i += 3;
+ remaining -= 3;
+ }
+
+ return sb.toString();
+ }
+
+ /**
+ * Convenience method for setting the given entry as a double.
+ * The double is converted with <code>Double.toString(double)</code>
+ * and then stored in the preference entry as that string.
+ *
+ * @exception NullPointerException if the key is null
+ * @exception IllegalArgumentException if the key length is to large
+ * @exception IllegalStateException when this node has been removed
+ */
+ public void putDouble(String key, double value) {
+ put(key, Double.toString(value));
+ }
+
+ /**
+ * Convenience method for setting the given entry as a float.
+ * The float is converted with <code>Float.toString(float)</code>
+ * and then stored in the preference entry as that string.
+ *
+ * @exception NullPointerException if the key is null
+ * @exception IllegalArgumentException if the key length is to large
+ * @exception IllegalStateException when this node has been removed
+ */
+ public void putFloat(String key, float value) {
+ put(key, Float.toString(value));
+ }
+
+ /**
+ * Convenience method for setting the given entry as an integer.
+ * The integer is converted with <code>Integer.toString(int)</code>
+ * and then stored in the preference entry as that string.
+ *
+ * @exception NullPointerException if the key is null
+ * @exception IllegalArgumentException if the key length is to large
+ * @exception IllegalStateException when this node has been removed
+ */
+ public void putInt(String key, int value) {
+ put(key, Integer.toString(value));
+ }
+
+ /**
+ * Convenience method for setting the given entry as a long.
+ * The long is converted with <code>Long.toString(long)</code>
+ * and then stored in the preference entry as that string.
+ *
+ * @exception NullPointerException if the key is null
+ * @exception IllegalArgumentException if the key length is to large
+ * @exception IllegalStateException when this node has been removed
+ */
+ public void putLong(String key, long value) {
+ put(key, Long.toString(value));
+ }
+
+ /**
+ * Removes the preferences entry from this preferences node.
+ * <p>
+ * The result will be immediatly visible in this VM, but may not be
+ * immediatly written to the backing store.
+ * <p>
+ * This implementation checks that the key is not larger then 80
+ * characters, gets the lock of this node, checks that the node has
+ * not been removed and calls <code>removeSpi</code> with the given key.
+ *
+ * @exception NullPointerException if the key is null
+ * @exception IllegalArgumentException if the key length is to large
+ * @exception IllegalStateException when this node has been removed
+ */
+ public void remove(String key) {
*** Patch too long, truncated ***
More information about the kaffe
mailing list