public override void run() { while (true) { EventObject eventJ = null; try { eventJ = getEventObject(); } catch (java.lang.InterruptedException e) { e.printStackTrace(); continue; } AbstractPreferences pref = (AbstractPreferences)eventJ .getSource(); if (eventJ is NodeAddEvent) { dispatchNodeAdd((NodeChangeEvent)eventJ, pref.nodeChangeListeners); } else if (eventJ is NodeRemoveEvent) { dispatchNodeRemove((NodeChangeEvent)eventJ, pref.nodeChangeListeners); } else if (eventJ is PreferenceChangeEvent) { dispatchPrefChange((PreferenceChangeEvent)eventJ, pref.preferenceChangeListeners); } } }
private AbstractPreferences getNodeFromBackend(bool createNew, AbstractPreferences currentNode, String name) { //throws BackingStoreException { if (name.length() > MAX_NAME_LENGTH) { // prefs.8=Name length is too long: {0} throw new java.lang.IllegalArgumentException("Name length is too long: " + name); } AbstractPreferences temp; if (createNew) { temp = currentNode.childSpi(name); currentNode.cachedNode.put(name, temp); if (temp.newNode && currentNode.nodeChangeListeners.size() > 0) { currentNode.notifyChildAdded(temp); } } else { temp = currentNode.getChild(name); } return(temp); }
private void removeNodeImpl()// throws BackingStoreException { { lock (lockJ) { checkState(); String[] childrenNames = childrenNamesSpi(); for (int i = 0; i < childrenNames.Length; i++) { if (null == cachedNode.get(childrenNames[i])) { AbstractPreferences child = childSpi(childrenNames[i]); cachedNode.put(childrenNames[i], child); } } java.util.Collection <AbstractPreferences> values = cachedNode.values(); AbstractPreferences[] children = values .toArray(new AbstractPreferences[values.size()]); foreach (AbstractPreferences child in children) { child.removeNodeImpl(); } removeNodeSpi(); isRemovedJ = true; parentPref.cachedNode.remove(nodeName); } if (parentPref.nodeChangeListeners.size() > 0) { parentPref.notifyChildRemoved(this); } }
public override Preferences node(String name) { AbstractPreferences startNode = null; lock (lockJ) { checkState(); validateName(name); if ("".equals(name)) //$NON-NLS-1$ { return(this); } else if ("/".equals(name)) //$NON-NLS-1$ { return(root); } if (name.startsWith("/")) //$NON-NLS-1$ { startNode = root; name = name.substring(1); } else { startNode = this; } } try { return(startNode.nodeImpl(name, true)); } catch (BackingStoreException e) { // should not happen return(null); } }
/* * ----------------------------------------------------------- Constructors * ----------------------------------------------------------- */ /* * Constructs a new {@code AbstractPreferences} instance using the given * parent node and node name. * * @param parent * the parent node of the new node or {@code null} to indicate * that the new node is a root node. * @param name * the name of the new node or an empty string to indicate that * this node is called "root". * @throws IllegalArgumentException * if the name contains a slash character or is empty if {@code * parent} is not {@code null}. */ protected AbstractPreferences(AbstractPreferences parent, String name) { if ((null == parent ^ name.length() == 0) || name.indexOf("/") >= 0) //$NON-NLS-1$ { throw new java.lang.IllegalArgumentException(); } root = null == parent ? this : parent.root; nodeChangeListeners = new LinkedList <EventListener>(); preferenceChangeListeners = new LinkedList <EventListener>(); isRemovedJ = false; cachedNode = new HashMap <String, AbstractPreferences>(); nodeName = name; parentPref = parent; lockJ = new Lock(); userNode = root.userNode; }
/* * Returns the child node with the specified name or {@code null} if it * doesn't exist. Implementers can assume that the name supplied to this * method will be a valid node name string (conforming to the node naming * format) and will not correspond to a node that has been cached or * removed. * * @param name * the name of the desired child node. * @return the child node with the given name or {@code null} if it doesn't * exist. * @throws BackingStoreException * if the backing store is unavailable or causes an operation * failure. */ protected AbstractPreferences getChild(String name) { // throws BackingStoreException { lock (lockJ) { checkState(); AbstractPreferences result = null; String[] childrenNamesJ = childrenNames(); for (int i = 0; i < childrenNamesJ.Length; i++) { if (childrenNamesJ[i].equals(name)) { result = childSpi(name); break; } } return(result); } }
public override bool nodeExists(String name)//throws BackingStoreException { { if (null == name) { throw new java.lang.NullPointerException(); } AbstractPreferences startNode = null; lock (lockJ) { if (isRemoved()) { if ("".equals(name)) //$NON-NLS-1$ { return(false); } // prefs.9=This node has been removed throw new java.lang.IllegalStateException("This node has been removed"); //$NON-NLS-1$ } validateName(name); if ("".equals(name) || "/".equals(name)) //$NON-NLS-1$ //$NON-NLS-2$ { return(true); } if (name.startsWith("/")) //$NON-NLS-1$ { startNode = root; name = name.substring(1); } else { startNode = this; } } try { Preferences result = startNode.nodeImpl(name, false); return(null == result ? false : true); } catch (java.lang.IllegalArgumentException e) { return(false); } }
private AbstractPreferences nodeImpl(String path, bool createNew) { //throws BackingStoreException { String[] names = path.split("/"); //$NON-NLS-1$ AbstractPreferences currentNode = this; AbstractPreferences temp = null; for (int i = 0; i < names.Length; i++) { String name = names[i]; lock (currentNode.lockJ) { temp = currentNode.cachedNode.get(name); if (temp == null) { temp = getNodeFromBackend(createNew, currentNode, name); } } currentNode = temp; if (null == currentNode) { break; } } return(currentNode); }
private AbstractPreferences getNodeFromBackend(bool createNew, AbstractPreferences currentNode, String name) { //throws BackingStoreException { if (name.length() > MAX_NAME_LENGTH) { // prefs.8=Name length is too long: {0} throw new java.lang.IllegalArgumentException("Name length is too long: "+ name); } AbstractPreferences temp; if (createNew) { temp = currentNode.childSpi(name); currentNode.cachedNode.put(name, temp); if (temp.newNode && currentNode.nodeChangeListeners.size() > 0) { currentNode.notifyChildAdded(temp); } } else { temp = currentNode.getChild(name); } return temp; }
/* * ----------------------------------------------------------- Constructors * ----------------------------------------------------------- */ /** * Constructs a new {@code AbstractPreferences} instance using the given * parent node and node name. * * @param parent * the parent node of the new node or {@code null} to indicate * that the new node is a root node. * @param name * the name of the new node or an empty string to indicate that * this node is called "root". * @throws IllegalArgumentException * if the name contains a slash character or is empty if {@code * parent} is not {@code null}. */ protected AbstractPreferences(AbstractPreferences parent, String name) { if ((null == parent ^ name.length() == 0) || name.indexOf("/") >= 0) { //$NON-NLS-1$ throw new java.lang.IllegalArgumentException(); } root = null == parent ? this : parent.root; nodeChangeListeners = new LinkedList<EventListener>(); preferenceChangeListeners = new LinkedList<EventListener>(); isRemovedJ = false; cachedNode = new HashMap<String, AbstractPreferences>(); nodeName = name; parentPref = parent; lockJ = new Lock(); userNode = root.userNode; }