Added WeakList and WeakMapList and made most relevant places use them. Should stop stuff not being GC'd after registering listeners and whatnot.

git-svn-id: http://svn.dmdirc.com/trunk@2543 00569f92-eb28-0410-84fd-f71c24880f

src/com/dmdirc/commandparser/CommandManager.java

@@ -41,6 +41,7 @@ import com.dmdirc.config.IdentityManager;
 import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.logger.Logger;
 import com.dmdirc.ui.input.TabCompleter;
+import com.dmdirc.util.WeakList;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -77,25 +78,25 @@ public final class CommandManager {
     /**
      * The parsers that have requested global commands.
      */
-    private static List<CommandParser> globalParsers = new ArrayList<CommandParser>();
+    private static List<CommandParser> globalParsers = new WeakList<CommandParser>();
     /**
      * The parsers that have requested server commands.
      */
-    private static List<CommandParser> serverParsers = new ArrayList<CommandParser>();
+    private static List<CommandParser> serverParsers = new WeakList<CommandParser>();
     /**
      * The parsers that have requested channel commands.
      */
-    private static List<CommandParser> channelParsers = new ArrayList<CommandParser>();
+    private static List<CommandParser> channelParsers = new WeakList<CommandParser>();
     /**
      * The parsers that have requested query commands.
      */
-    private static List<CommandParser> queryParsers = new ArrayList<CommandParser>();
+    private static List<CommandParser> queryParsers = new WeakList<CommandParser>();
     
     /**
      * Channel commands that have been registered to appear in the nicklist
      * popup.
      */
-    private static List<Command> channelPopupCommands = new ArrayList<Command>();
+    private static List<Command> channelPopupCommands = new WeakList<Command>();
     
     /** The command char we're using. */
     private static char commandChar = IdentityManager.getGlobalConfig()
@@ -194,8 +195,6 @@ public final class CommandManager {
      */
     private static void registerCommand(final Command command,
             final List<CommandParser> parsers, final boolean register) {
-        // FIXME: There's no way to kill old/dead entries in the *Parsers lists.
-        //        Ideally, they'd unregister themselves (or so) when unloaded.
         for (CommandParser parser : parsers) {
             if (register) {
                 parser.registerCommand(command);

src/com/dmdirc/config/ConfigManager.java

@@ -22,7 +22,7 @@
 
 package com.dmdirc.config;
 
-import com.dmdirc.util.MapList;
+import com.dmdirc.util.WeakMapList;
 
 import java.io.Serializable;
 import java.util.ArrayList;
@@ -53,8 +53,8 @@ public final class ConfigManager extends ConfigSource implements Serializable,
     private List<Identity> sources;
     
     /** The listeners registered for this manager. */
-    private final MapList<String, ConfigChangeListener> listeners
-            = new MapList<String, ConfigChangeListener>();
+    private final WeakMapList<String, ConfigChangeListener> listeners
+            = new WeakMapList<String, ConfigChangeListener>();
     
     /** The ircd this manager is for. */
     private final String ircd;

src/com/dmdirc/config/Identity.java

@@ -26,6 +26,7 @@ import com.dmdirc.Main;
 import com.dmdirc.Precondition;
 import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.logger.Logger;
+import com.dmdirc.util.WeakList;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -72,7 +73,7 @@ public class Identity extends ConfigSource implements Serializable,
     
     /** The config change listeners for this source. */
     protected final List<ConfigChangeListener> listeners
-            = new ArrayList<ConfigChangeListener>();
+            = new WeakList<ConfigChangeListener>();
     
     /** The file that this identity is read from. */
     protected File file;

src/com/dmdirc/config/IdentityManager.java

@@ -45,6 +45,7 @@ public final class IdentityManager {
     private final static List<Identity> identities = new ArrayList<Identity>();
     
     /** The config managers that have registered with this manager. */
+    // XXX: Should this be a weak list?
     private final static List<ConfigManager> managers = new ArrayList<ConfigManager>();
     
     /** The identity file used for the global config. */

src/com/dmdirc/updater/Update.java

@@ -27,11 +27,9 @@ import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.logger.Logger;
 import com.dmdirc.updater.Update.STATUS;
 import com.dmdirc.util.Downloader;
-import java.io.IOException;
-import java.net.MalformedURLException;
-import java.util.ArrayList;
+import com.dmdirc.util.WeakList;
+
 import java.util.List;
-import java.util.logging.Level;
 
 /**
  * Represents a single available update for some component.
@@ -64,7 +62,7 @@ public final class Update {
 
     /** A list of registered update listeners. */
     private final List<UpdateListener> listeners
-            = new ArrayList<UpdateListener>();
+            = new WeakList<UpdateListener>();
 
     /** Our current status. */
     private STATUS status = Update.STATUS.PENDING;

src/com/dmdirc/util/MapList.java

@@ -40,7 +40,7 @@ import java.util.Set;
 public class MapList<S,T> {
     
     /** Our internal map. */
-    private final Map<S, List<T>> map = new HashMap<S, List<T>>();
+    protected final Map<S, List<T>> map = new HashMap<S, List<T>>();
 
     /**
      * Determines if this MapList is empty. An empty MapList is one that either
@@ -109,7 +109,7 @@ public class MapList<S,T> {
      * @param key The key to retrieve
      * @return A list of the specified key's values
      */
-    private List<T> safeGet(final S key) {
+    protected List<T> safeGet(final S key) {
         if (!map.containsKey(key)) {
             map.put(key, new ArrayList<T>());
         }

src/com/dmdirc/util/WeakList.java

@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.util;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+/**
+ *
+ * @param <T>
+ * @author chris
+ */
+public class WeakList<T> implements List<T> {
+
+    private final List<WeakReference<T>> list = new ArrayList<WeakReference<T>>();
+
+    public WeakList() {
+        super();
+    }
+
+    private void cleanUp() {
+        for (int i = 0; i < list.size(); i++) {
+            if (list.get(i).get() == null) {
+                list.remove(i--);
+            }
+        }
+    }
+
+    private List<T> dereferenceList(final List<WeakReference<T>> list) {
+        final List<T> res = new ArrayList<T>();
+
+        for (WeakReference<T> item : list) {
+            if (item.get() != null) {
+                res.add(item.get());
+            }
+        }
+
+        return res;
+    }
+
+    @SuppressWarnings(value = "unchecked")
+    private Collection<WeakReference<T>> referenceCollection(final Collection<?> c) {
+        final Collection<WeakReference<T>> res = new ArrayList<WeakReference<T>>();
+
+        for (Object item : c) {
+            res.add(new WeakReference(item));
+        }
+
+        return res;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int size() {
+        cleanUp();
+
+        return list.size();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean isEmpty() {
+        cleanUp();
+
+        return list.isEmpty();
+    }
+
+    /** {@inheritDoc} */
+    @Override @SuppressWarnings(value = "unchecked")
+    public boolean contains(Object o) {
+        return list.contains(new WeakReference(o));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public Iterator<T> iterator() {
+        return dereferenceList(list).iterator();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public Object[] toArray() {
+        return dereferenceList(list).toArray();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public <T> T[] toArray(T[] a) {
+        return dereferenceList(list).toArray(a);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean add(T e) {
+        return list.add(new WeakReference<T>(e));
+    }
+
+    /** {@inheritDoc} */
+    @Override @SuppressWarnings(value = "unchecked")
+    public boolean remove(Object o) {
+        return list.remove(new WeakReference(o));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean containsAll(Collection<?> c) {
+        return dereferenceList(list).containsAll(c);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean addAll(Collection<? extends T> c) {
+        return list.addAll(referenceCollection(c));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean addAll(int index, Collection<? extends T> c) {
+        return list.addAll(index, referenceCollection(c));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean removeAll(Collection<?> c) {
+        return list.removeAll(referenceCollection(c));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean retainAll(Collection<?> c) {
+        return list.retainAll(referenceCollection(c));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void clear() {
+        list.clear();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public T get(int index) {
+        cleanUp();
+
+        return list.get(index).get();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public T set(int index, T element) {
+        list.set(index, new WeakReference<T>(element));
+
+        return element;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void add(int index, T element) {
+        list.add(index, new WeakReference<T>(element));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public T remove(int index) {
+        return list.remove(index).get();
+    }
+
+    /** {@inheritDoc} */
+    @Override @SuppressWarnings(value = "unchecked")
+    public int indexOf(Object o) {
+        cleanUp();
+
+        return list.indexOf(new WeakReference(o));
+    }
+
+    /** {@inheritDoc} */
+    @Override @SuppressWarnings(value = "unchecked")
+    public int lastIndexOf(Object o) {
+        cleanUp();
+
+        return list.lastIndexOf(new WeakReference(o));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public ListIterator<T> listIterator() {
+        cleanUp();
+
+        return dereferenceList(list).listIterator();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public ListIterator<T> listIterator(int index) {
+        cleanUp();
+
+        return dereferenceList(list).listIterator(index);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public List<T> subList(int fromIndex, int toIndex) {
+        return dereferenceList(list.subList(fromIndex, toIndex));
+    }
+}

src/com/dmdirc/util/WeakMapList.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.util;
+
+import java.util.List;
+
+/**
+ * Wraps a Map<S, List<T>> with various convenience methods for
+ * accessing the data. Implements a Map-like interface for easier transition.
+ * This implementation uses WeakLists (i.e., lists of weak references) - all
+ * references to values are wrapped in WeakReferences.
+ * 
+ * @param <S> the type of keys maintained by this map
+ * @param <T> the type of mapped values
+ * @author chris
+ */
+public class WeakMapList<S,T> extends MapList<S,T> {
+    
+    /**
+     * Retrieves the list of values associated with the specified key, creating
+     * the key if neccessary.
+     * 
+     * @param key The key to retrieve
+     * @return A list of the specified key's values
+     */
+    @Override
+    protected List<T> safeGet(final S key) {
+        if (!map.containsKey(key)) {
+            map.put(key, new WeakList<T>());
+        }
+        
+        return map.get(key);
+    }
+}