ListenerList is now perfectly, magically thread safe

There's no longer any need to synchronise when adding or
iterating to a listener list.

Change-Id: Ie39fbd92650bebffb13524e6054b187c3699833e
Reviewed-on: http://gerrit.dmdirc.com/1124
Reviewed-by: Gregory Holmes <greg@dmdirc.com>
Automatic-Compile: Chris Smith <chris@dmdirc.com>

src/com/dmdirc/util/ListenerList.java

 
 package com.dmdirc.util;
 
-import java.util.List;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentSkipListSet;
 
 /**
  * Represents a list of event listeners, similar to EventListenerList, but
 public class ListenerList {
     
     /** The map of class->listener or string->listener that we're using. */
-    private final MapList<Object, Object> listeners
-            = new MapList<Object, Object>();
+    private final Map<Object, Collection<Object>> listeners
+            = new HashMap<Object, Collection<Object>>();
     
     /**
      * Creates a new instance of ListenerList.
      * @param listener The listener to be added
      */
     public <T> void add(final Class<T> listenerType, final T listener) {
-        listeners.add(listenerType, listener);
+        if (!listeners.containsKey(listenerType)) {
+            listeners.put(listenerType, new ConcurrentSkipListSet<Object>());
+        }
+
+        listeners.get(listenerType).add(listener);
     }
     
     /**
      * @param listener The listener to be added
      */
     public void add(final String listenerType, final Object listener) {
-        listeners.add(listenerType, listener);
+        if (!listeners.containsKey(listenerType)) {
+            listeners.put(listenerType, new ConcurrentSkipListSet<Object>());
+        }
+
+        listeners.get(listenerType).add(listener);
     }
     
     /**
      * @param listener The listener to be removed
      */
     public <T> void remove(final Class<T> listenerType, final T listener) {
-        listeners.remove(listenerType, listener);
+        listeners.get(listenerType).remove(listener);
     }
     
     /**
      * @param listener The listener to be removed
      */
     public void remove(final String listenerType, final Object listener) {
-        listeners.remove(listenerType, listener);
+        listeners.get(listenerType).remove(listener);
     }
     
     /**
      * @return A list of listeners for the specified type
      */
     @SuppressWarnings("unchecked")
-    public <T> List<T> get(final Class<T> listenerType) {
+    public <T> Collection<T> get(final Class<T> listenerType) {
         if (listeners.containsKey(listenerType)) {
-            return (List<T>) listeners.get(listenerType);
+            return (Collection<T>) listeners.get(listenerType);
         } else {
-            return new WeakList<T>();
+            return new ConcurrentSkipListSet<T>();
         }
     }
     
      * @param listenerType The type of listener to be retrieved
      * @return A list of listeners for the specified type
      */
-    public List<Object> get(final String listenerType) {
+    public Collection<Object> get(final String listenerType) {
         if (listeners.containsKey(listenerType)) {
             return listeners.get(listenerType);
         } else {
-            return new WeakList<Object>();
+            return new ConcurrentSkipListSet<Object>();
         }
     }