Initial import of util classes

src/com/dmdirc/util/ConfigFile.java

@@ -0,0 +1,370 @@
+/*
+ * Copyright (c) 2006-2010 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.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.GregorianCalendar;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Reads and writes a standard DMDirc config file.
+ *
+ * @author chris
+ */
+public class ConfigFile extends TextFile {
+
+    /** A list of domains in this config file. */
+    private final List<String> domains = new ArrayList<String>();
+
+    /** The values associated with each flat domain. */
+    private final MapList<String, String> flatdomains = new MapList<String, String>();
+
+    /** The key/value sets associated with each key domain. */
+    private final Map<String, Map<String, String>> keydomains
+            = new HashMap<String, Map<String, String>>();
+    
+    /** Whether or not we should automatically create domains. */
+    private boolean automake;
+
+    /**
+     * Creates a new read-only Config File from the specified input stream.
+     * 
+     * @param is The input stream to read
+     */
+    public ConfigFile(final InputStream is) {
+        super(is, Charset.forName("UTF-8"));
+    }
+
+    /**
+     * Creates a new Config File from the specified file.
+     * 
+     * @param file The file to read/write
+     */
+    public ConfigFile(final File file) {
+        super(file, Charset.forName("UTF-8"));
+    }
+
+    /**
+     * Creates a new Config File from the specified file.
+     * 
+     * @param filename The name of the file to read/write
+     */
+    public ConfigFile(final String filename) {
+        this(new File(filename));
+    }
+
+    /**
+     * Sets the "automake" value of this config file. If automake is set to
+     * true, any calls to getKeyDomain will automatically create the domain
+     * if it did not previously exist.
+     * 
+     * @param automake The new value of the automake setting of this file
+     */
+    public void setAutomake(final boolean automake) {
+        this.automake = automake;
+    }
+
+    /**
+     * Reads the data from the file.
+     * 
+     * @throws FileNotFoundException if the file is not found
+     * @throws IOException if an i/o exception occured when reading
+     * @throws InvalidConfigFileException if the config file isn't valid
+     */
+    public void read() throws FileNotFoundException, IOException, InvalidConfigFileException {
+        String domain = null;
+        boolean keydomain = false;
+        int offset;
+        
+        keydomains.clear();
+        flatdomains.clear();
+        domains.clear();
+        
+        readLines();
+
+        for (String line : getLines()) {
+            String tline = line;
+            
+            while (!tline.isEmpty() && (tline.charAt(0) == '\t' || 
+                    tline.charAt(0) == ' ')) {
+                tline = tline.substring(1);
+            }
+
+            if (tline.indexOf('#') == 0 || tline.isEmpty()) {
+                continue;
+            } else if (
+                    (tline.endsWith(":") && !tline.endsWith("\\:"))
+                    && findEquals(tline) == -1) {
+                domain = unescape(tline.substring(0, tline.length() - 1));
+
+                domains.add(domain);
+
+                keydomain = keydomains.containsKey(domain)
+                        || flatdomains.containsValue("keysections", domain);
+                
+                if (keydomain && !keydomains.containsKey(domain)) {
+                    keydomains.put(domain, new HashMap<String, String>());
+                } else if (!keydomain && !flatdomains.containsKey(domain)) {
+                    flatdomains.add(domain);
+                }
+            } else if (domain != null && keydomain
+                    && (offset = findEquals(tline)) != -1) {
+                final String key = unescape(tline.substring(0, offset));
+                final String value = unescape(tline.substring(offset + 1));
+
+                keydomains.get(domain).put(key, value);
+            } else if (domain != null && !keydomain) {
+                flatdomains.add(domain, unescape(tline));
+            } else {
+                throw new InvalidConfigFileException("Unknown or unexpected" +
+                        " line encountered: " + tline);
+            }
+        }
+    }
+
+    /**
+     * Writes the contents of this ConfigFile to disk.
+     * 
+     * @throws IOException if the write operation fails
+     */
+    public void write() throws IOException {
+        if (!isWritable()) {
+            throw new UnsupportedOperationException("Cannot write to a file "
+                    + "that isn't writable");
+        }
+        
+        final List<String> lines = new ArrayList<String>();
+
+        lines.add("# This is a DMDirc configuration file.");
+        lines.add("# Written on: " + new GregorianCalendar().getTime().toString());
+
+        writeMeta(lines);
+
+        for (String domain : domains) {
+            if ("keysections".equals(domain)) {
+                continue;
+            }
+
+            lines.add("");
+
+            lines.add(escape(domain) + ':');
+
+            if (flatdomains.containsKey(domain)) {
+                for (String entry : flatdomains.get(domain)) {
+                    lines.add("  " + escape(entry));
+                }
+            } else {
+                for (Map.Entry<String, String> entry : keydomains.get(domain).entrySet()) {
+                    lines.add("  " + escape(entry.getKey()) + "="
+                            + escape(entry.getValue()));
+                }
+            }
+        }
+
+        writeLines(lines);
+    }
+    
+    /**
+     * Appends the meta-data (keysections) to the specified list of lines.
+     * 
+     * @param lines The set of lines to be appended to
+     */
+    private void writeMeta(final List<String> lines) {
+        lines.add("");
+        lines.add("# This section indicates which sections below take key/value");
+        lines.add("# pairs, rather than a simple list. It should be placed above");
+        lines.add("# any sections that take key/values.");
+        lines.add("keysections:");
+
+        for (String domain : domains) {
+            if ("keysections".equals(domain)) {
+                continue;
+            } else if (keydomains.containsKey(domain)) {
+                lines.add("  " + domain);
+            }
+        }
+    }
+    
+    /**
+     * Retrieves all the key domains for this config file.
+     * 
+     * @return This config file's key domains
+     */
+    public Map<String, Map<String, String>> getKeyDomains() {
+        return keydomains;
+    }
+    
+    /**
+     * Retrieves the key/values of the specified key domain.
+     * 
+     * @param domain The domain to be retrieved
+     * @return A map of keys to values in the specified domain
+     */
+    public Map<String, String> getKeyDomain(final String domain) {
+        if (automake && !isKeyDomain(domain)) {
+            domains.add(domain);
+            keydomains.put(domain, new HashMap<String, String>());
+        }
+        
+        return keydomains.get(domain);
+    }
+    
+    /**
+     * Retrieves the content of the specified flat domain.
+     * 
+     * @param domain The domain to be retrieved
+     * @return A list of lines in the specified domain
+     */
+    public List<String> getFlatDomain(final String domain) {
+        return flatdomains.get(domain);
+    }
+    
+    /**
+     * Determines if this config file has the specified domain.
+     * 
+     * @param domain The domain to check for
+     * @return True if the domain is known, false otherwise
+     */
+    public boolean hasDomain(final String domain) {
+        return keydomains.containsKey(domain) || flatdomains.containsKey(domain);
+    }
+
+    /**
+     * Determines if this config file has the specified domain, and the domain
+     * is a key domain.
+     * 
+     * @param domain The domain to check for
+     * @return True if the domain is known and keyed, false otherwise
+     */
+    public boolean isKeyDomain(final String domain) {
+        return keydomains.containsKey(domain);
+    }
+
+    /**
+     * Determines if this config file has the specified domain, and the domain
+     * is a flat domain.
+     * 
+     * @param domain The domain to check for
+     * @return True if the domain is known and flat, false otherwise
+     */
+    public boolean isFlatDomain(final String domain) {
+        return flatdomains.containsKey(domain);
+    }
+    
+    /**
+     * Adds a new flat domain to this config file.
+     * 
+     * @param name The name of the domain to be added
+     * @param data The content of the domain
+     */
+    public void addDomain(final String name, final List<String> data) {
+        domains.add(name);
+        flatdomains.add(name, data);
+    }
+
+    /**
+     * Adds a new key domain to this config file.
+     * 
+     * @param name The name of the domain to be added
+     * @param data The content of the domain
+     */    
+    public void addDomain(final String name, final Map<String, String> data) {
+        domains.add(name);
+        keydomains.put(name, data);
+    }
+    
+    /**
+     * Unescapes any escaped characters in the specified input string.
+     * 
+     * @param input The string to unescape
+     * @return The string with all escape chars (\) resolved
+     */
+    protected static String unescape(final String input) {
+        boolean escaped = false;
+        final StringBuilder temp = new StringBuilder();
+
+        for (int i = 0; i < input.length(); i++) {
+            final char ch = input.charAt(i);
+
+            if (escaped) {
+                if (ch == 'n') {
+                    temp.append('\n');
+                } else if (ch == 'r') {
+                    temp.append('\r');
+                } else {
+                    temp.append(ch);
+                }
+                
+                escaped = false;
+            } else if (ch == '\\') {
+                escaped = true;
+            } else {
+                temp.append(ch);
+            }
+        }
+        
+        return temp.toString();
+    }
+    
+    /**
+     * Escapes the specified input string by prefixing all occurances of
+     * \, \n, \r, =, # and : with backslashes.
+     * 
+     * @param input The string to be escaped
+     * @return A backslash-armoured version of the string
+     */
+    protected static String escape(final String input) {
+        return input.replaceAll("\\\\", "\\\\\\\\").replaceAll("\n", "\\\\n")
+                .replaceAll("\r", "\\\\r").replaceAll("=", "\\\\=")
+                .replaceAll(":", "\\\\:").replaceAll("#", "\\\\#");
+    }
+    
+    /**
+     * Finds the first non-escaped instance of '=' in the specified string.
+     * 
+     * @param input The string to be searched
+     * @return The offset of the first non-escaped instance of '=', or -1.
+     */
+    protected static int findEquals(final String input) {
+        boolean escaped = false;
+        
+        for (int i = 0; i < input.length(); i++) {
+            if (escaped) {
+                escaped = false;
+            } else if (input.charAt(i) == '\\') {
+                escaped = true;
+            } else if (input.charAt(i) == '=') {
+                return i;
+            }
+        }
+        
+        return -1;
+    }
+}

src/com/dmdirc/util/DoubleMap.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2006-2010 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.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * An object that maps keys to values, and values back to keys. Currently
+ * does no checking for duplicates. Does not allow null values.
+ * 
+ * @param <A> The first type of data to be mapped
+ * @param <B> The second type of data to be mapped 
+ * @author chris
+ */
+public class DoubleMap<A,B> {
+    
+    /** The keys in this map. */
+    protected final List<A> keys = new ArrayList<A>();
+    /** The values in this map. */
+    protected final List<B> values = new ArrayList<B>();
+    
+    /**
+     * Adds the specified pair to this map.
+     * 
+     * @param key The key for the map
+     * @param value The value for the map
+     */
+    public void put(final A key, final B value) {
+        if (key == null || value == null) {
+            throw new NullPointerException();
+        }
+        
+        keys.add(key);
+        values.add(value);
+    }
+    
+    /**
+     * Retrieves the value associated with the specified key.
+     * 
+     * @param key The key to search for 
+     * @return The value of the specified key
+     */
+    public B getValue(final A key) {
+        return values.get(keys.indexOf(key));
+    }
+    
+    /**
+     * Retrieves the key associated with the specified value.
+     * 
+     * @param value The value to search for
+     * @return The key of the specified value
+     */
+    public A getKey(final B value) {
+        return keys.get(values.indexOf(value));
+    }
+    
+    /**
+     * Retrieves the set of keys in this double map.
+     * 
+     * @return This map's key set
+     */
+    public Set<A> keySet() {
+        return new HashSet<A>(keys);
+    }
+    
+    /**
+     * Retrieves the set of values in this double map.
+     * 
+     * @return This map's value set
+     */
+    public Set<B> valueSet() {
+        return new HashSet<B>(values);
+    }
+
+}

src/com/dmdirc/util/EquatableWeakReference.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2006-2010 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.Reference;
+import java.lang.ref.WeakReference;
+
+/**
+ * An extension of WeakReference that implements a sane equals and hashcode
+ * method.
+ * 
+ * @param <T> The type of object that this reference contains
+ * @author chris
+ */
+public class EquatableWeakReference<T> extends WeakReference<T> {
+    
+    /**
+     * Creates a new instance of EquatableWeakReference.
+     * 
+     * @param referent The object that this weak reference should reference.
+     */
+    public EquatableWeakReference(T referent) {
+        super(referent);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Reference) {
+            return get().equals(((Reference) obj).get());
+        } else {
+            return get().equals(obj);
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int hashCode() {
+        return get().hashCode();
+    }
+    
+}

src/com/dmdirc/util/InvalidConfigFileException.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2006-2010 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;
+
+/**
+ * Thrown to indicate that a config file is invalid.
+ * @author chris
+ */
+public class InvalidConfigFileException extends Exception {
+    
+    /**
+     * A version number for this class. It should be changed whenever the class
+     * structure is changed (or anything else that would prevent serialized
+     * objects being unserialized with the new class).
+     */    
+    private static final long serialVersionUID = 1;
+
+    /**
+     * Creates a new InvalidConfigFileException.
+     * 
+     * @param string A description of the exception that occured.
+     */
+    public InvalidConfigFileException(String string) {
+        super(string);
+    }
+
+}

src/com/dmdirc/util/ListenerList.java

@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2006-2010 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;
+
+/**
+ * Represents a list of event listeners, similar to EventListenerList, but
+ * not swing specific.
+ * 
+ * @author chris
+ */
+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>();
+    
+    /**
+     * Creates a new instance of ListenerList.
+     */
+    public ListenerList() {
+        // Do nothing
+    }
+    
+    /**
+     * Adds a new listener of the specified type to this listener list.
+     * 
+     * @param listenerType The type of listener to be added
+     * @param listener The listener to be added
+     */
+    public <T> void add(final Class<T> listenerType, final T listener) {
+        listeners.add(listenerType, listener);
+    }
+    
+    /**
+     * Adds a new listener of the specified type to this listener list.
+     * 
+     * @param listenerType The name of the type of listener that's being added
+     * @param listener The listener to be added
+     */
+    public void add(final String listenerType, final Object listener) {
+        listeners.add(listenerType, listener);
+    }
+    
+    /**
+     * Removes the specified listener from the list of listeners for the
+     * specified type.
+     * 
+     * @param listenerType The type that the listener should be removed from
+     * @param listener The listener to be removed
+     */
+    public <T> void remove(final Class<T> listenerType, final T listener) {
+        listeners.remove(listenerType, listener);
+    }
+    
+    /**
+     * Removes the specified listener from the list of listeners for the
+     * specified type.
+     * 
+     * @param listenerType The name of the type that the listener should be
+     * removed from
+     * @param listener The listener to be removed
+     */
+    public void remove(final String listenerType, final Object listener) {
+        listeners.remove(listenerType, listener);
+    }
+    
+    /**
+     * Retrieves the list of listeners for the specified type.
+     * 
+     * @param listenerType The type of listener that's being retrieved
+     * @return A list of listeners for the specified type
+     */
+    @SuppressWarnings("unchecked")
+    public <T> List<T> get(final Class<T> listenerType) {
+        if (listeners.containsKey(listenerType)) {
+            return (List<T>) listeners.get(listenerType);
+        } else {
+            return new WeakList<T>();
+        }
+    }
+    
+    /**
+     * Retrieves the list of listeners for the specified type.
+     * 
+     * @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) {
+        if (listeners.containsKey(listenerType)) {
+            return listeners.get(listenerType);
+        } else {
+            return new WeakList<Object>();
+        }
+    }
+
+}

src/com/dmdirc/util/MapList.java

@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) 2006-2010 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.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Wraps a Map<S, List<T>> with various convenience methods for
+ * accessing the data. Implements a Map-like interface for easier transition.
+ * 
+ * @param <S> the type of keys maintained by this map
+ * @param <T> the type of mapped values
+ * @author chris
+ */
+public class MapList<S,T> {
+    
+    /** Our internal map. */
+    protected final Map<S, List<T>> map;
+
+    /**
+     * Creates a new, empty MapList.
+     */
+    public MapList() {
+        map = new HashMap<S, List<T>>();
+    }
+
+    /**
+     * Creates a new MapList with the values from the specified list.
+     * 
+     * @param list The MapList whose values should be used
+     */
+    public MapList(final MapList<S,T> list) {
+        map = list.getMap();
+    }
+
+    /**
+     * Determines if this MapList is empty. An empty MapList is one that either
+     * contains no keys, or contains only keys which have no associated values.
+     * 
+     * @return True if this MapList is empty, false otherwise
+     */
+    public boolean isEmpty() {
+        for (List<T> list : map.values()) {
+            if (!list.isEmpty()) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+
+    /**
+     * Determines if this MapList contains the specified key.
+     * 
+     * @param key The key to look for
+     * @return True if this MapList contains the specified key, false otherwise
+     */
+    public boolean containsKey(final S key) {
+        return map.containsKey(key);
+    }
+
+    /**
+     * Determines if this MapList contains the specified value as a child of
+     * the specified key.
+     * 
+     * @param key The key to search under
+     * @param value The value to look for
+     * @return True if this MapList contains the specified key/value pair, 
+     * false otherwise
+     */
+    public boolean containsValue(final S key, final T value) {
+        return map.containsKey(key) && map.get(key).contains(value);
+    }
+
+    /**
+     * Retrieves the list of values associated with the specified key.
+     * 
+     * @param key The key whose values are being retrieved
+     * @return The values belonging to the specified key
+     */
+    public List<T> get(final S key) {
+        return map.get(key);
+    }
+    
+    /**
+     * Retrieves the value at the specified offset of the specified key.
+     * 
+     * @param key The key whose values are being retrieved
+     * @param index The index of the value to retrieve
+     * @return The specified value of the key
+     */    
+    public T get(final S key, final int index) {
+        return map.get(key).get(index);
+    }    
+    
+    /**
+     * 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
+     */
+    public List<T> safeGet(final S key) {
+        if (!map.containsKey(key)) {
+            map.put(key, new ArrayList<T>());
+        }
+        
+        return map.get(key);
+    }
+    
+    /**
+     * Adds the specified key to the MapList.
+     * 
+     * @param key The key to be added
+     */
+    public void add(final S key) {
+        safeGet(key);
+    }    
+
+    /**
+     * Adds the specified value as a child of the specified key. If the key
+     * didn't previous exist, it is created.
+     * 
+     * @param key The key to which the value is being added
+     * @param value The value to be added
+     */
+    public void add(final S key, final T value) {
+        safeGet(key).add(value);
+    }
+
+    /**
+     * Adds the specified set of values to the specified key. If the key
+     * didn't previous exist, it is created.
+     * 
+     * @param key The key to which the value is being added
+     * @param values The values to be added
+     */    
+    public void add(final S key, final Collection<T> values) {
+        safeGet(key).addAll(values);
+    }    
+
+    /**
+     * Removes the specified key and all of its values.
+     * 
+     * @param key The key to remove
+     */    
+    public void remove(final S key) {
+        map.remove(key);
+    }
+    
+    /**
+     * Removes the specified value from all keys.
+     * 
+     * @param value The value to remove
+     */
+    public void removeFromAll(final T value) {
+        for (List<T> list : map.values()) {
+            list.remove(value);
+        }
+    }
+
+    /**
+     * Removes the specified value from the specified key.
+     * 
+     * @param key The key whose value is being removed
+     * @param value The value to be removed
+     */
+    public void remove(final S key, final T value) {
+        if (map.containsKey(key)) {
+            map.get(key).remove(value);
+        }
+    }    
+
+    /**
+     * Entirely clears this MapList.
+     */
+    public void clear() {
+        map.clear();
+    }
+    
+    /**
+     * Clears all values of the specified key.
+     * 
+     * @param key The key to be cleared
+     */
+    public void clear(final S key) {
+        safeGet(key).clear();
+    }    
+
+    /**
+     * Returns the set of all keys belonging to this MapList.
+     * 
+     * @return This MapList's keyset
+     */
+    public Set<S> keySet() {
+        return map.keySet();
+    }
+
+    /**
+     * Returns a collection of all values belonging to the specified key.
+     * 
+     * @param key The key whose values are being sought
+     * @return A collection of values belonging to the key
+     */
+    public Collection<T> values(final S key) {
+        return map.get(key);
+    }
+    
+    /**
+     * Retrieves the entry set for this MapList.
+     * 
+     * @return This MapList's entry set
+     */
+    public Set<Map.Entry<S, List<T>>> entrySet() {
+        return map.entrySet();
+    }
+    
+    /**
+     * Retrieves the map behind this maplist.
+     * 
+     * @return This MapList's map.
+     */
+    public Map<S, List<T>> getMap() {
+        return new HashMap<S, List<T>>(map);
+    }
+
+}

src/com/dmdirc/util/ReturnableThread.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2006-2010 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;
+
+/**
+ * Normal thread with the potential to return a value.
+ * 
+ * @param T Type to be returned
+ */
+public abstract class ReturnableThread<T> extends Thread {
+
+    /** Returnable object. */
+    private T value;
+
+    /** {@inheritDoc} */
+    @Override
+    public abstract void run();
+
+    /**
+     * Sets the returnable object.
+     * 
+     * @param value new returnable object
+     */
+    public void setObject(final T value) {
+        this.value = value;
+    }
+
+    /**
+     * Returns the object set by this thread.
+     * 
+     * @return Returnable object
+     */
+    public T getObject() {
+        return value;
+    }
+}

src/com/dmdirc/util/RollingList.java

@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) 2006-2010 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.ArrayList;
+import java.util.List;
+
+/**
+ * Implements a "rolling list". A rolling list has a maximum capacity, and
+ * removes the oldest elements from the list to maintain this capacity.
+ * 
+ * @param <T> The type if items that this list contains 
+ * @author chris
+ */
+public class RollingList<T> {
+   
+    /** The items in this rolling list. */
+    private final List<T> items = new ArrayList<T>();
+    
+    /** The maximum capacity of this list. */
+    private final int capacity;
+    
+    /** This list's position pointer. */
+    private int position = 0;
+    
+    /** Whether or not to add a fake empty item to the end of this list. */
+    private boolean addEmpty;
+    /** The "empty" item to be added. */
+    private T empty;
+    
+    /**
+     * Creates a new RollingList of the specified capacity.
+     * 
+     * @param capacity The capacity of this list.
+     */
+    public RollingList(final int capacity) {
+        this.capacity = capacity;
+        this.addEmpty = false;
+    }
+
+    /**
+     * Creates a new RollingList of the specified capacity, with the specified
+     * "empty" element appended to the end.
+     * 
+     * @param capacity The capacity of this list.
+     * @param empty The "empty" element to be added
+     */    
+    public RollingList(final int capacity, final T empty) {
+        this.capacity = capacity;
+        this.addEmpty = true;
+        this.empty = empty;
+    }
+
+    /**
+     * Removes the specified element from this list.
+     * 
+     * @param o The object to be removed from the list.
+     * @return True if the list contained the specified element, false otherwise.
+     */
+    public boolean remove(final Object o) {
+        return items.remove(o);
+    }
+
+    /**
+     * Determines if this list is currently empty.
+     * 
+     * @return True if the list is empty, false otherwise.
+     */
+    public boolean isEmpty() {
+        return items.isEmpty();
+    }
+
+    /**
+     * Retrieves the item at the specified index in this list.
+     * 
+     * @param index The index to look up
+     * @return The item at the specified index
+     */
+    public T get(final int index) {
+        return items.get(index);
+    }
+
+    /**
+     * Determines if this list contains the specified object.
+     * 
+     * @param o The object to be checked
+     * @return True if this list contains the item, false otherwise.
+     */
+    public boolean contains(final Object o) {
+        return items.contains(o);
+    }
+
+    /**
+     * Clears all items from this list.
+     */
+    public void clear() {
+        items.clear();
+    }  
+    
+    /**
+     * Adds the specified item to this list. If the list has reached its
+     * maximum capacity, this method will remove elements from the start of the
+     * list until there is sufficient room for the new element.
+     * 
+     * @param e The element to be added to the list.
+     * @return True
+     */
+    public boolean add(T e) {
+        while (items.size() > capacity - 1) {
+            items.remove(0);
+            position--;
+        }
+        
+        return items.add(e);
+    }
+    
+    /**
+     * Retrieves the current position within the list.
+     * 
+     * @return This list's positional pointer
+     */
+    public int getPosition() {
+        return position;
+    }
+
+    /**
+     * Sets the positional pointer of this list.
+     * 
+     * @param position The new position
+     */
+    public void setPosition(int position) {
+        this.position = position;
+    }    
+    
+    /**
+     * Determines if there is an element after the positional pointer of the list.
+     * 
+     * @return True if there is an element, false otherwise.
+     */
+    public boolean hasNext() {
+        return (items.size() > position + 1) || ((items.size() > position) && addEmpty);
+    }
+    
+    /**
+     * Retrieves the element after the positional pointer of the list.
+     * 
+     * @return The next element in the list
+     */
+    public T getNext() {
+        if (items.size() > position + 1 || !addEmpty) {
+            return get(++position);
+        } else {
+            position++;
+            return empty;
+        }
+    }
+    
+    /**
+     * Determines if there is an element befpre the positional pointer of the list.
+     * 
+     * @return True if there is an element, false otherwise.
+     */    
+    public boolean hasPrevious() {
+        return 0 < position;
+    }
+    
+    /**
+     * Retrieves the element before the positional pointer of the list.
+     * 
+     * @return The previous element in the list
+     */    
+    public T getPrevious() {
+        return get(--position);
+    }    
+    
+    /**
+     * Sets the positional pointer of this list to the end.
+     */
+    public void seekToEnd() {
+        position = items.size();
+    }
+    
+    /**
+     * Sets the positional pointer of this list to the start.
+     */
+    public void seekToStart() {
+        position = 0;
+    }
+    
+    /**
+     * Retrieves a list of items that this rolling list contains.
+     * 
+     * @return A list of items in this rolling list.
+     */
+    public List<T> getList() {
+        return new ArrayList<T>(items);
+    }
+
+}

src/com/dmdirc/util/StreamUtil.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2006-2010 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.io.Closeable;
+import java.io.IOException;
+
+/**
+ * Utilities for dealing with streams.
+ *
+ * @since 0.6.3m2
+ * @author chris
+ */
+public abstract class StreamUtil {
+
+    /**
+     * Closes the stream if it is non-null, and ignores any IOExceptions
+     * raised by doing so.
+     *
+     * @param stream The stream to be closed
+     */
+    public static void close(final Closeable stream) {
+        if (stream != null) {
+            try {
+                stream.close();
+            } catch (IOException ex) {
+                // Do nothing. We don't care.
+            }
+        }
+    }
+
+}

src/com/dmdirc/util/TextFile.java

@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2006-2010 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.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Allows reading and writing to a plain text file via a list of lines.
+ * 
+ * @author chris
+ */
+public class TextFile {
+    
+    /** The file we're dealing with. */
+    private File file;
+    
+    /** The input stream we're dealing with. */
+    private InputStream is;
+    
+    /** The lines we've read from the file. */
+    private List<String> lines;
+
+    /** The charset to use to read the file. */
+    private final Charset charset;
+    
+    /**
+     * Creates a new instance of TextFile for the specified file, and uses the
+     * default charset.
+     * 
+     * @param filename The file to be read/written
+     */
+    public TextFile(final String filename) {
+        this(new File(filename));
+    }
+
+    /**
+     * Creates a new instance of TextFile for the specified File, and uses the
+     * default charset.
+     * 
+     * @param file The file to read
+     */
+    public TextFile(final File file) {
+        this(file, Charset.defaultCharset());
+    }
+    
+    /**
+     * Creates a new instance of TextFile for an input stream, and uses the
+     * default charset.
+     * 
+     * @param is The input stream to read from
+     */
+    public TextFile(final InputStream is) {
+        this(is, Charset.defaultCharset());
+    }
+
+    /**
+     * Creates a new instance of TextFile for the specified File, which is to
+     * be read using the specified charset.
+     *
+     * @param file The file to read
+     * @param charset The charset to read the file in
+     * @since 0.6.3m1
+     */
+    public TextFile(final File file, final Charset charset) {
+        this.file = file;
+        this.charset = charset;
+    }
+
+    /**
+     * Creates a new instance of TextFile for an input stream, which is to
+     * be read using the specified charset.
+     *
+     * @param is The input stream to read from
+     * @param charset The charset to read the file in
+     * @since 0.6.3m1
+     */
+    public TextFile(final InputStream is, final Charset charset) {
+        this.is = is;
+        this.charset = charset;
+    }
+    
+    /**
+     * Retrieves the contents of the file as a list of lines. If getLines() or
+     * readLines() has previously been called, a cached version is returned.
+     * 
+     * @return A list of lines in the file
+     * @throws IOException if an I/O exception occurs
+     */
+    public List<String> getLines() throws IOException {
+        if (lines == null) {
+            readLines();
+        }
+        
+        return lines;
+    }
+    
+    /**
+     * Reads the contents of the file into this TextFile's line cache.
+     * 
+     * @throws IOException If an I/O exception occurs
+     */
+    public void readLines() throws IOException {
+        BufferedReader reader = null;
+        InputStreamReader inputReader = null;
+        InputStream inputStream = null;
+
+        try {
+            inputStream = file == null ? is : new FileInputStream(file);
+            inputReader = new InputStreamReader(inputStream, charset);
+            reader = new BufferedReader(inputReader);
+            lines = new ArrayList<String>();
+
+            String line;
+
+            while ((line = reader.readLine()) != null) {
+                lines.add(line);
+            }
+        } finally {
+            StreamUtil.close(reader);
+            StreamUtil.close(inputReader);
+            StreamUtil.close(inputStream);
+        }
+    }
+    
+    /**
+     * Determines if this file is writable or not.
+     * 
+     * @return True if the file is writable, false otherwise
+     */
+    public boolean isWritable() {
+        return file != null;
+    }
+    
+    /**
+     * Writes the specified list of lines to the file.
+     * 
+     * @param lines The lines to be written
+     * @throws IOException if an I/O exception occurs
+     */
+    public void writeLines(final List<String> lines) throws IOException {
+        if (file == null) {
+            throw new UnsupportedOperationException("Cannot write to TextFile "
+                    + "opened with an InputStream");
+        }
+        
+        BufferedWriter writer = null;
+
+        try {
+            writer = new BufferedWriter(new FileWriter(file));
+        
+            for (String line : lines) {
+                writer.write(line);
+                writer.newLine();
+            }
+        } finally {
+            StreamUtil.close(writer);
+        }
+    }
+
+    /**
+     * Retrieves the File for this TextFile, if there is one.
+     * 
+     * @return This TextFile's file, or null
+     */
+    public File getFile() {
+        return file;
+    }
+    
+    /**
+     * Deletes the file associated with this textfile, if there is one.
+     */
+    public void delete() {
+        if (file == null) {
+            throw new UnsupportedOperationException("Cannot delete TextFile "
+                    + "opened with an InputStream");
+        }
+        
+        file.delete();
+    }
+
+}

src/com/dmdirc/util/WeakList.java

@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) 2006-2010 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;
+
+/**
+ * Implements a list of weak references. The weak references (and subsequent
+ * garbage collection) are handled transparently.
+ * 
+ * @param <T> The type of object that this list will contain.
+ * @author chris
+ */
+public class WeakList<T> implements List<T> {
+
+    /** The items in this list. */
+    private final List<WeakReference<T>> list = new ArrayList<WeakReference<T>>();
+
+    /**
+     * Creates a new instance of WeakList.
+     */
+    public WeakList() {
+        super();
+    }
+
+    /**
+     * Removes any entries from the list that have been GC'd.
+     */
+    private void cleanUp() {
+        for (int i = 0; i < list.size(); i++) {
+            if (list.get(i).get() == null) {
+                list.remove(i--);
+            }
+        }
+    }
+
+    /**
+     * Dereferences the specified list of WeakReferences to get a plain List.
+     * 
+     * @param list The list to be dereferenced
+     * @return A list containing the items referenced by the specified list
+     */
+    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;
+    }
+
+    /**
+     * Creates a new collection of weak references to elements in the specified
+     * collection.
+     * 
+     * @param c The collection whose elements should be referenced
+     * @return A copy of the specified collection, with each item wrapped in
+     * a weak reference.
+     */
+    @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 EquatableWeakReference(item));
+        }
+
+        return res;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int size() {
+        cleanUp();
+
+        return list.size();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean isEmpty() {
+        cleanUp();
+
+        return list.isEmpty();
+    }
+
+    /** {@inheritDoc} */
+    @Override @SuppressWarnings("unchecked")
+    public boolean contains(final Object o) {
+        return list.contains(new EquatableWeakReference(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(final T[] a) {
+        return dereferenceList(list).toArray(a);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean add(final T e) {
+        return list.add(new EquatableWeakReference<T>(e));
+    }
+
+    /** {@inheritDoc} */
+    @Override @SuppressWarnings(value = "unchecked")
+    public boolean remove(final Object o) {
+        return list.remove(new EquatableWeakReference(o));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean containsAll(final Collection<?> c) {
+        return dereferenceList(list).containsAll(c);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean addAll(final Collection<? extends T> c) {
+        return list.addAll(referenceCollection(c));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean addAll(final int index, final Collection<? extends T> c) {
+        return list.addAll(index, referenceCollection(c));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean removeAll(final Collection<?> c) {
+        return list.removeAll(referenceCollection(c));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean retainAll(final Collection<?> c) {
+        return list.retainAll(referenceCollection(c));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void clear() {
+        list.clear();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public T get(final int index) {
+        cleanUp();
+
+        return list.get(index).get();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public T set(final int index, final T element) {
+        list.set(index, new EquatableWeakReference<T>(element));
+
+        return element;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void add(final int index, final T element) {
+        list.add(index, new EquatableWeakReference<T>(element));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public T remove(final int index) {
+        return list.remove(index).get();
+    }
+
+    /** {@inheritDoc} */
+    @Override @SuppressWarnings(value = "unchecked")
+    public int indexOf(final Object o) {
+        cleanUp();
+
+        return list.indexOf(o);
+    }
+
+    /** {@inheritDoc} */
+    @Override @SuppressWarnings(value = "unchecked")
+    public int lastIndexOf(final Object o) {
+        cleanUp();
+
+        return list.lastIndexOf(o);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public ListIterator<T> listIterator() {
+        cleanUp();
+
+        return dereferenceList(list).listIterator();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public ListIterator<T> listIterator(final int index) {
+        cleanUp();
+
+        return dereferenceList(list).listIterator(index);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public List<T> subList(final int fromIndex, final int toIndex) {
+        return dereferenceList(list.subList(fromIndex, toIndex));
+    }
+}

src/com/dmdirc/util/WeakMapList.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2006-2010 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
+    public List<T> safeGet(final S key) {
+        if (!map.containsKey(key)) {
+            map.put(key, new WeakList<T>());
+        }
+        
+        return map.get(key);
+    }
+}

test/com/dmdirc/addons/ConfigFileTest.java

@@ -0,0 +1,248 @@
+
+/*
+ * Copyright (c) 2006-2010 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.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class ConfigFileTest {
+    
+    private ConfigFile cf;
+    
+    @Before
+    public void setUp() throws Exception {
+        cf = new ConfigFile(getClass().getClassLoader().
+                    getResourceAsStream("com/dmdirc/util/test2.txt"));
+    }    
+
+    @Test
+    public void testRead() {
+        boolean err = false;
+        
+        try {
+            cf.read(); 
+        } catch (FileNotFoundException ex) {
+            err = true;
+        } catch (IOException ex) {
+            err = true;
+        } catch (InvalidConfigFileException ex) {
+            err = true;
+        }
+        
+        assertFalse(err);
+    }
+    
+    @Test
+    public void testDomains() {
+        testRead();
+        assertTrue(cf.hasDomain("keysections"));
+        assertTrue(cf.hasDomain("section alpha"));
+        assertTrue(cf.hasDomain("section one point one"));
+        assertTrue(cf.hasDomain("section one"));
+        assertFalse(cf.hasDomain("random domain"));
+    }
+    
+    @Test
+    public void testKeyDomains() {
+        testRead();
+        assertTrue(cf.isKeyDomain("section one"));
+        assertFalse(cf.isKeyDomain("section one point one"));
+        assertFalse(cf.isKeyDomain("section two"));
+    }
+    
+    @Test
+    public void testFlatDomains() {
+        testRead();
+        assertTrue(cf.isFlatDomain("keysections"));
+        assertTrue(cf.isFlatDomain("section alpha"));
+        assertTrue(cf.isFlatDomain("section one point one"));
+        assertFalse(cf.isFlatDomain("section one"));
+        assertFalse(cf.hasDomain("random domain"));        
+    }
+    
+    @Test
+    public void testFlatDomainContents() {
+        testRead();
+        assertEquals(2, cf.getFlatDomain("section alpha").size());
+        assertEquals("line 1", cf.getFlatDomain("section alpha").get(0));
+        assertEquals("line 2", cf.getFlatDomain("section alpha").get(1));
+    }
+    
+    @Test
+    public void testKeyDomainContents() {
+        testRead();
+        assertEquals(3, cf.getKeyDomain("section one").size());
+        assertEquals("one", cf.getKeyDomain("section one").get("1"));
+        assertEquals("two", cf.getKeyDomain("section one").get("2"));
+        assertEquals("three", cf.getKeyDomain("section one").get("3"));
+    }
+    
+    @Test
+    public void testColons() throws IOException, InvalidConfigFileException {
+        final File file = File.createTempFile("DMDirc.unittest", null);
+        ConfigFile config = new ConfigFile(file);
+        Map<String, String> data = new HashMap<String, String>();
+        data.put("test1", "hello");
+        data.put("test:2", "hello");
+        data.put("test3", "hello:");
+        config.addDomain("test", data);
+        config.write();
+        
+        config = new ConfigFile(file);
+        config.read();
+        
+        assertTrue(config.isKeyDomain("test"));
+        data = config.getKeyDomain("test");
+        assertEquals("hello", data.get("test1"));
+        assertEquals("hello", data.get("test:2"));
+        assertEquals("hello:", data.get("test3"));
+    }
+    
+    @Test
+    public void testEquals() throws IOException, InvalidConfigFileException {
+        final File file = File.createTempFile("DMDirc.unittest", null);
+        ConfigFile config = new ConfigFile(file);
+        Map<String, String> data = new HashMap<String, String>();
+        data.put("test1", "hello");
+        data.put("test=2", "hello");
+        data.put("test3", "hello=");
+        config.addDomain("test", data);
+        config.write();
+        
+        config = new ConfigFile(file);
+        config.read();
+        
+        assertTrue(config.isKeyDomain("test"));
+        data = config.getKeyDomain("test");
+        assertEquals("hello", data.get("test1"));
+        assertEquals("hello", data.get("test=2"));
+        assertEquals("hello=", data.get("test3"));
+    }
+    
+    @Test
+    public void testNewlines() throws IOException, InvalidConfigFileException {
+        final File file = File.createTempFile("DMDirc.unittest", null);
+        ConfigFile config = new ConfigFile(file);
+        Map<String, String> data = new HashMap<String, String>();
+        data.put("test1", "hello");
+        data.put("test2", "hello\ngoodbye");
+        data.put("test3", "hello\n");
+        data.put("test4", "hello\r\ngoodbye");
+        config.addDomain("test", data);
+        config.write();
+        
+        config = new ConfigFile(file);
+        config.read();
+        
+        assertTrue(config.isKeyDomain("test"));
+        data = config.getKeyDomain("test");
+        assertEquals("hello", data.get("test1"));
+        assertEquals("hello\ngoodbye", data.get("test2"));
+        assertEquals("hello\n", data.get("test3"));
+        assertEquals("hello\r\ngoodbye", data.get("test4"));
+    }
+    
+    @Test
+    public void testBackslash() throws IOException, InvalidConfigFileException {
+        final File file = File.createTempFile("DMDirc.unittest", null);
+        ConfigFile config = new ConfigFile(file);
+        Map<String, String> data = new HashMap<String, String>();
+        data.put("test1", "hello\\");
+        data.put("test2", "\\nhello");
+        data.put("test3\\", "hello");
+        config.addDomain("test", data);
+        config.write();
+        
+        config = new ConfigFile(file);
+        config.read();
+        
+        assertTrue(config.isKeyDomain("test"));
+        data = config.getKeyDomain("test");
+        assertEquals("hello\\", data.get("test1"));
+        assertEquals("\\nhello", data.get("test2"));
+        assertEquals("hello", data.get("test3\\"));
+    }
+    
+    @Test
+    public void testHash() throws IOException, InvalidConfigFileException {
+        final File file = File.createTempFile("DMDirc.unittest", null);
+        ConfigFile config = new ConfigFile(file);
+        Map<String, String> data = new HashMap<String, String>();
+        data.put("test1#", "hello");
+        data.put("#test2", "hello");
+        data.put("test3", "#hello");
+        config.addDomain("test", data);
+        config.write();
+        
+        config = new ConfigFile(file);
+        config.read();
+        
+        assertTrue(config.isKeyDomain("test"));
+        data = config.getKeyDomain("test");
+        assertEquals("hello", data.get("test1#"));
+        assertEquals("hello", data.get("#test2"));
+        assertEquals("#hello", data.get("test3"));
+    }    
+    
+    @Test
+    public void testEscape() {
+        final String input = "blah blah\\foo\r\nbar=:";
+        final String output = "blah blah\\\\foo\\r\\nbar\\=\\:";
+        assertEquals(output, ConfigFile.escape(input));
+    }
+    
+    @Test
+    public void testUnescape() {
+        final String input = "blah blah\\foo\r\nbar=:";
+        assertEquals(input, ConfigFile.unescape(ConfigFile.escape(input)));
+    }
+    
+    @Test
+    public void testDelete() throws IOException {
+        final File file = File.createTempFile("DMDirc_unittest", null);
+        ConfigFile config = new ConfigFile(file);
+        config.write();
+        assertTrue(file.exists());
+        config.delete();
+        assertFalse(file.exists());
+    }
+    
+    @Test
+    public void testDuplicateKeys() throws IOException, InvalidConfigFileException {
+        final ConfigFile file = new ConfigFile(getClass().getResourceAsStream("test2.txt"));
+        file.read();
+        
+        assertTrue(file.isKeyDomain("section one"));
+        assertEquals(3, file.getKeyDomain("section one").size());
+        assertTrue(file.isFlatDomain("section one point one"));
+    }
+
+}

test/com/dmdirc/addons/DoubleMapTest.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2006-2010 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 org.junit.Test;
+import static org.junit.Assert.*;
+
+public class DoubleMapTest {
+
+    @Test
+    public void testPut() {
+        final DoubleMap<String, String> dm = new DoubleMap<String, String>();
+        dm.put("a", "b");
+        
+        assertEquals(1, dm.keySet().size());
+        assertEquals(1, dm.valueSet().size());
+        assertTrue(dm.keySet().contains("a"));
+        assertTrue(dm.valueSet().contains("b"));
+    }
+    
+    @Test(expected=NullPointerException.class)
+    public void testPutNull1() {
+        final DoubleMap<String, String> dm = new DoubleMap<String, String>();
+        dm.put(null, "b");
+    }
+    
+    @Test(expected=NullPointerException.class)
+    public void testPutNull2() {
+        final DoubleMap<String, String> dm = new DoubleMap<String, String>();
+        dm.put("a", null);
+    }    
+    
+    @Test
+    public void testGet() {
+        final DoubleMap<String, String> dm = new DoubleMap<String, String>();
+        dm.put("a", "b");
+        dm.put("b", "c");
+        dm.put("c", "a");
+        
+        assertEquals("b", dm.getValue("a"));
+        assertEquals("b", dm.getKey("c"));
+        assertEquals("c", dm.getKey("a"));
+    }    
+
+}

test/com/dmdirc/addons/EquatableWeakReferenceTest.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2006-2010 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.Reference;
+import java.lang.ref.WeakReference;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class EquatableWeakReferenceTest {
+
+    @Test
+    public void testEquals() {
+        final Object myObject = "moo";
+        final Reference<Object> myRef = new WeakReference<Object>(myObject);
+        final EquatableWeakReference<Object> ewf = new EquatableWeakReference<Object>(myObject);
+
+        assertTrue(ewf.equals(myObject));
+        assertTrue(ewf.equals(myRef));
+        assertFalse(ewf.equals("bar"));
+        assertFalse(ewf.equals(new WeakReference<Object>("bar")));
+    }
+
+    @Test
+    public void testHashCode() {
+        final Object myObject = "moo";
+        final EquatableWeakReference<Object> ewf = new EquatableWeakReference<Object>(myObject);
+        
+        assertEquals(myObject.hashCode(), ewf.hashCode());
+    }
+
+}

test/com/dmdirc/addons/InvalidConfigFileExceptionTest.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2006-2010 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 org.junit.Test;
+import static org.junit.Assert.*;
+
+public class InvalidConfigFileExceptionTest {
+
+    @Test
+    public void testMessage() {
+        final InvalidConfigFileException iae = new InvalidConfigFileException("message");
+        
+        assertEquals("message", iae.getMessage());
+    }
+
+}

test/com/dmdirc/addons/MapListTest.java

@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 2006-2010 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.ArrayList;
+import java.util.List;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class MapListTest {
+
+    @Test
+    public void testIsEmpty() {
+        final MapList<String, String> test = new MapList<String, String>();
+        assertTrue(test.isEmpty());
+
+        test.add("a", "b");
+        assertFalse(test.isEmpty());
+        test.removeFromAll("b");
+        assertTrue(test.isEmpty());
+    }
+    
+    @Test
+    public void testAddCollection() {
+        final MapList<String, String> test = new MapList<String, String>();
+        final List<String> testList = new ArrayList<String>();
+        testList.add("d");
+        testList.add("e");
+        test.add("key", testList);
+        
+        assertTrue(test.containsKey("key"));
+        assertTrue(test.containsValue("key", "d"));
+        assertTrue(test.containsValue("key", "e"));
+    }
+    
+    @Test
+    public void testClear() {
+        final MapList<String, String> test = new MapList<String, String>();
+        test.add("a", "b");
+        test.add("d", "e");
+        test.clear();
+        assertTrue(test.isEmpty());
+    }
+    
+    @Test
+    public void testClearKey() {
+        final MapList<String, String> test = new MapList<String, String>();
+        test.add("a", "b");
+        test.add("d", "e");
+        test.clear("a");
+        assertTrue(test.values("a").isEmpty());
+        assertFalse(test.isEmpty());
+    }
+    
+    @Test
+    public void testRemove() {
+        final MapList<String, String> test = new MapList<String, String>();
+        test.add("a", "b");
+        test.add("d", "e");
+        test.remove("z", "b");
+        
+        assertEquals(2, test.keySet().size());
+        assertEquals(1, test.values("a").size());
+        assertEquals(1, test.values("d").size());
+        
+        test.remove("a", "b");
+        assertEquals(2, test.keySet().size());
+        assertEquals(0, test.values("a").size());
+        assertEquals(1, test.values("d").size());        
+    }    
+    
+    @Test
+    public void testKeySet() {
+        final MapList<String, String> test = new MapList<String, String>();
+        test.add("a", "b");
+        test.add("d", "e");
+        assertEquals(2, test.keySet().size());
+        assertTrue(test.keySet().contains("a"));
+        assertTrue(test.keySet().contains("d"));
+    }    
+
+    @Test
+    public void testContainsKey() {
+        final MapList<String, String> test = new MapList<String, String>();
+        test.add("a", "b");
+        assertTrue(test.containsKey("a"));
+    }
+
+    @Test
+    public void testContainsValue() {
+        final MapList<String, String> test = new MapList<String, String>();
+        test.add("a", "b");
+        assertTrue(test.containsValue("a", "b"));
+    }
+
+    @Test
+    public void testGet() {
+        final MapList<String, String> test = new MapList<String, String>();
+        test.add("a", "b");
+        assertEquals(1, test.get("a").size());
+        assertEquals("b", test.get("a").get(0));
+        assertEquals("b", test.get("a", 0));
+    }
+    
+    @Test
+    public void testInherit() {
+        final MapList<String, String> test1 = new MapList<String, String>();
+        test1.add("a", "b");
+        
+        final MapList<String, String> test2 = new MapList<String, String>(test1);
+        assertEquals(1, test2.get("a").size());
+        assertEquals("b", test2.get("a").get(0));
+        assertEquals("b", test2.get("a", 0));        
+    }
+    
+    @Test
+    public void testGetMap() {
+        final MapList<String, String> test1 = new MapList<String, String>();
+        test1.add("a", "b");
+        assertNotSame(test1.getMap(), test1.getMap());
+        
+        final MapList<String, String> test2 = new MapList<String, String>(test1);
+        assertEquals(test1.getMap(), test2.getMap());
+    }    
+
+}

test/com/dmdirc/addons/RollingListTest.java

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2006-2010 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 org.junit.Test;
+import static org.junit.Assert.*;
+
+public class RollingListTest {
+
+    @Test
+    public void testIsEmpty() {
+        final RollingList<String> rl = new RollingList<String>(1);
+        assertTrue(rl.isEmpty());
+        assertTrue(rl.getList().isEmpty());
+        
+        rl.add("Foo");
+        assertFalse(rl.isEmpty());
+        assertFalse(rl.getList().isEmpty());
+    }
+    
+    @Test
+    public void testRolling() {
+        final RollingList<String> rl = new RollingList<String>(1);
+        
+        rl.add("Foo");
+        rl.add("Bar");
+        rl.add("Baz");
+
+        assertEquals("Baz", rl.get(0));
+        assertEquals(1, rl.getList().size());
+        assertFalse(rl.contains("Bar"));
+    }
+    
+    @Test
+    public void testClear() {
+        final RollingList<String> rl = new RollingList<String>(3);
+        
+        rl.add("Foo");
+        rl.add("Bar");
+        rl.add("Baz");
+        rl.clear();
+        
+        assertTrue(rl.isEmpty());
+        assertTrue(rl.getList().isEmpty());
+    }
+    
+    @Test
+    public void testPositions() {
+        final RollingList<String> rl = new RollingList<String>(3);
+        
+        rl.add("Foo");
+        rl.add("Bar");
+        rl.add("Baz");
+        
+        assertEquals(0, rl.getPosition());
+        
+        rl.seekToEnd();
+        assertEquals(3, rl.getPosition());
+        
+        rl.seekToStart();
+        assertEquals(0, rl.getPosition());
+    }
+    
+    @Test
+    public void testPrevNext() {
+        final RollingList<String> rl = new RollingList<String>(3);
+        
+        rl.add("Foo");
+        rl.add("Bar");
+        rl.add("Baz");
+        
+        assertEquals("Bar", rl.getNext());
+        assertEquals("Baz", rl.getNext());
+        assertFalse(rl.hasNext());
+        assertTrue(rl.hasPrevious());
+        
+        assertEquals("Bar", rl.getPrevious());
+        assertEquals("Foo", rl.getPrevious());
+        assertFalse(rl.hasPrevious());
+        assertTrue(rl.hasNext());
+    }
+    
+    @Test
+    public void testEmpty() {
+        final RollingList<String> rl = new RollingList<String>(1, "Meep");
+        rl.add("Foo");
+        
+        assertEquals("Meep", rl.getNext());
+        assertFalse(rl.hasNext());
+        
+        rl.add("Bar");
+        
+        // The position moves when adding
+        assertTrue(rl.hasNext());
+        assertFalse(rl.hasPrevious());
+        assertEquals("Meep", rl.getNext());
+        assertEquals("Bar", rl.getPrevious());
+    }
+
+}

test/com/dmdirc/addons/TextFileTest.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2006-2010 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.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class TextFileTest {
+    
+    private static File tfile;
+
+    @Test
+    public void testGetLines() throws IOException {
+        final TextFile file =
+                new TextFile(getClass().getClassLoader().
+                getResource("com/dmdirc/util/test1.txt").openStream());
+        final List<String> lines = file.getLines();
+
+        assertEquals(7, lines.size());
+        assertEquals("Line 1", lines.get(0));
+    }
+    
+    @Test
+    public void testGetLines2() throws IOException {
+        final TextFile file =
+                new TextFile(getClass().getClassLoader().
+                getResource("com/dmdirc/util/test1.txt").openStream());
+        final List<String> lines = file.getLines();
+
+        assertEquals(7, lines.size());
+        assertEquals("Line 1", lines.get(0));
+    }
+    
+    @Test
+    public void testWrite() throws IOException {
+        tfile = File.createTempFile("dmdirc_unit_test", null);
+        TextFile file = new TextFile(tfile);
+        
+        final List<String> lines = Arrays.asList(new String[]{
+            "hello", "this is a test", "meep"
+        });
+        
+        file.writeLines(lines);
+        
+        file = new TextFile(tfile);
+        final List<String> newLines = file.getLines();
+        
+        assertEquals(lines, newLines);
+    }
+    
+    @Test(expected=UnsupportedOperationException.class)
+    public void testIllegalWrite() throws IOException {
+        final TextFile file =
+                new TextFile(getClass().getClassLoader().
+                getResource("com/dmdirc/util/test1.txt").openStream());
+        file.writeLines(Arrays.asList(new String[]{
+            "hello", "this is a test", "meep"
+        }));
+    }
+    
+    @Test(expected=UnsupportedOperationException.class)
+    public void testIllegalDelete() throws IOException {
+        final TextFile file =
+                new TextFile(getClass().getClassLoader().
+                getResource("com/dmdirc/util/test1.txt").openStream());
+        file.delete();
+    }
+    
+    @Test
+    public void testDelete() {
+        assertTrue(tfile.exists());
+        TextFile file = new TextFile(tfile);
+        file.delete();
+        assertFalse(tfile.exists());
+    }
+    
+}

test/com/dmdirc/addons/WeakListTest.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2006-2010 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 org.junit.Test;
+import static org.junit.Assert.*;
+
+public class WeakListTest {
+
+    @Test
+    public void testBasics() {
+        final WeakList<String> test = new WeakList<String>();
+        assertTrue(test.isEmpty());
+        
+        test.add("abcdef");
+        test.add("123");
+        
+        assertEquals(2, test.size());
+        assertTrue(test.get(0).equals("abcdef"));
+        assertTrue(test.contains("123"));
+        assertFalse(test.isEmpty());
+        
+        test.remove("abcdef");
+        assertFalse(test.contains("abcdef"));
+        
+        test.remove("123");
+        assertTrue(test.isEmpty());
+    }
+
+}

test/com/dmdirc/addons/test1.txt

@@ -0,0 +1,7 @@
+Line 1
+Line 2
+Line 3
+Line 4
+Line 5
+Line 6
+Line 7

test/com/dmdirc/addons/test2.txt

@@ -0,0 +1,21 @@
+# This is a DMDirc configuration file.
+# Written on: Mon Dec 17 23:32:19 GMT 2007
+
+# This section indicates which sections below take key/value
+# pairs, rather than a simple list. It should be placed above
+# any sections that take key/values.
+
+keysections:
+  section one
+
+section alpha:
+  line 1
+  line 2
+
+section one point one:
+  line 1
+
+section one:
+  1=one
+  2=two
+  3=three

test/com/dmdirc/addons/test3.txt

@@ -0,0 +1,25 @@
+# This is a DMDirc configuration file.
+# Written on: Mon Dec 17 23:32:19 GMT 2007
+
+# This section indicates which sections below take key/value
+# pairs, rather than a simple list. It should be placed above
+# any sections that take key/values.
+
+keysections:
+  section one
+
+section alpha:
+  line 1
+  line 2
+
+section one point one:
+  line 1
+
+section one:
+  1=one
+  2=two
+  3=three
+
+section one:
+
+section one point one: