java.util.prefs.NodeChangeListener Java Examples

private void fireNodeEvents(List<EventBag<NodeChangeListener, NodeChangeEvent>> events) {
    if (noEvents) {
        return;
    }
    
    for(EventBag<NodeChangeListener, NodeChangeEvent> bag : events) {
        for(NodeChangeEvent event : bag.getEvents()) {
            for(NodeChangeListener l : bag.getListeners()) {
                try {
                    if ((event instanceof NodeChangeEventExt) && ((NodeChangeEventExt) event).isRemovalEvent()) {
                        l.childRemoved(event);
                    } else {
                        l.childAdded(event);
                    }
                } catch (Throwable t) {
                    LOG.log(Level.WARNING, null, t);
                }
            }
        }
    }
}
 

protected void notifyNCL(NodeChangeEvent evt, boolean bAdded) {
  synchronized(nclSet) {
    
    for(Iterator<NodeChangeListener> it = nclSet.iterator(); it.hasNext(); ) {
      NodeChangeListener ncl = it.next();
      try {
        if(bAdded) {
          ncl.childAdded(evt);
        } else {
          ncl.childRemoved(evt);
        }
      } catch (Exception e) {
        Activator.log.warn("Failed to notify " + ncl);
      }
    }
  }
}
 

@Override
public void removeNodeChangeListener(NodeChangeListener ncl) {
    try {
        super.removeNodeChangeListener(ncl);
    } catch (IllegalArgumentException e) {
        // ignore, see #143581
    }
}
 

@Override
public void sync() throws BackingStoreException {
    ArrayList<EventBag<PreferenceChangeListener, PreferenceChangeEvent>> prefEvents = new ArrayList<EventBag<PreferenceChangeListener, PreferenceChangeEvent>>();
    ArrayList<EventBag<NodeChangeListener, NodeChangeEvent>> nodeEvents = new ArrayList<EventBag<NodeChangeListener, NodeChangeEvent>>();

    synchronized (tree.treeLock()) {
        _sync(prefEvents, nodeEvents);
    }

    fireNodeEvents(nodeEvents);
    firePrefEvents(prefEvents);
}
 

private ProxyPreferences(ProxyPreferences parent, MemoryPreferences memoryPref, Preferences delegate) {
    this.parent = parent;
    this.delegateRoot = memoryPref;
    this.delegate = delegate == null ? memoryPref.getPreferences() : delegate;
    weakPrefListener = WeakListeners.create(PreferenceChangeListener.class, this, delegate);
    this.delegate.addPreferenceChangeListener(weakPrefListener);
    weakNodeListener = WeakListeners.create(NodeChangeListener.class, this, delegate);
    this.delegate.addNodeChangeListener(weakNodeListener);
}
 

@Override
public void removeNodeChangeListener(NodeChangeListener nl) {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

@Override
public void removeNodeChangeListener(NodeChangeListener ncl) {
  this.nodeChangeListeners.remove(ncl);
}
 

@Override
public void addNodeChangeListener(NodeChangeListener ncl) {
  this.nodeChangeListeners.add(ncl);
}
 

@Override
public void removeNodeChangeListener(@Nonnull final NodeChangeListener ncl) {
}
 

@Override
public void addNodeChangeListener(@Nonnull final NodeChangeListener ncl) {
}
 

public void 	removeNodeChangeListener(NodeChangeListener ncl) {
  synchronized(nclSet) {
    super.removeNodeChangeListener(ncl);
    nclSet.remove(ncl);
  }
}
 

public void 	addNodeChangeListener(NodeChangeListener ncl) {
  synchronized(nclSet) {
    super.addNodeChangeListener(ncl);
    nclSet.add(ncl);
  }
}
 

@Override
public void removeNodeChangeListener(NodeChangeListener ncl) {
    synchronized (this) {
        nodeListeners.remove(ncl);
    }
}
 

@Override
public void addNodeChangeListener(NodeChangeListener ncl) {
    synchronized (this) {
        nodeListeners.add(ncl);
    }
}
 

private ProxyPreferencesImpl node(String pathName, boolean create, List<EventBag<NodeChangeListener, NodeChangeEvent>> events) {
    if (pathName.length() > 0 && pathName.charAt(0) == '/') { //NOI18N
        // absolute path, if this is not the root then find the root
        // and pass the call to it
        if (parent != null) {
            Preferences root = this;
            while (root.parent() != null) {
                root = root.parent();
            }
            return ((ProxyPreferencesImpl) root).node(pathName, create, events);
        } else {
            // this is the root, change the pathName to a relative path and proceed
            pathName = pathName.substring(1);
        }
    }

    if (pathName.length() > 0) {
        String childName;
        String pathFromChild;

        int idx = pathName.indexOf('/'); //NOI18N
        if (idx != -1) {
            childName = pathName.substring(0, idx);
            pathFromChild = pathName.substring(idx + 1);
        } else {
            childName = pathName;
            pathFromChild = null;
        }

        ProxyPreferencesImpl child = children.get(childName);
        if (child == null) {
            if (removedChildren.contains(childName) && !create) {
                // this child has been removed
                return null;
            }
            
            Preferences childDelegate = null;
            try {
                if (delegate != null && delegate.nodeExists(childName)) {
                    childDelegate = delegate.node(childName);
                }
            } catch (BackingStoreException bse) {
                // ignore
            }

            if (childDelegate != null || create) {
                child = tree.get(this, childName, childDelegate);
                children.put(childName, child);
                removedChildren.remove(childName);

                // fire event if we really created the new child node
                if (childDelegate == null) {
                    EventBag<NodeChangeListener, NodeChangeEvent> bag = new EventBag<NodeChangeListener, NodeChangeEvent>();
                    bag.addListeners(nodeListeners);
                    bag.addEvent(new NodeChangeEventExt(this, child, false));
                    events.add(bag);
                }
            } else {
                // childDelegate == null && !create
                return null;
            }
        } else {
            assert !child.removed;
        }

        return pathFromChild != null ? child.node(pathFromChild, create, events) : child;
    } else {
        return this;
    }
}
 

@Override
public void removeNodeChangeListener(NodeChangeListener ncl) {
    synchronized (tree.treeLock()) {
        nodeListeners.remove(ncl);
    }
}
 

@Override
public void addNodeChangeListener(NodeChangeListener ncl) {
    synchronized (tree.treeLock()) {
        nodeListeners.add(ncl);
    }
}
 

@Override
public void addNodeChangeListener(NodeChangeListener nl) {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

@Override
public void addNodeChangeListener(NodeChangeListener ncl) {

}
 

@Override
public void removeNodeChangeListener(NodeChangeListener ncl) {

}
 

@Override
public void addNodeChangeListener(NodeChangeListener ncl) {

}
 

@Override
public void removeNodeChangeListener(NodeChangeListener ncl) {

}