Fix line endings and trailing spaces

Change-Id: I36ccd739efef6b633cb8f927d820f7bfba49875f
Reviewed-on: http://gerrit.dmdirc.com/1922
Reviewed-by: Greg Holmes <greg@dmdirc.com>
Automatic-Compile: DMDirc Local Commits <dmdirc@googlemail.com>

src/com/dmdirc/util/ConfigFile.java

     /** 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) {
 
     /**
      * Creates a new Config File from the specified file.
-     * 
+     *
      * @param file The file to read/write
      */
     public ConfigFile(final File file) {
 
     /**
      * Creates a new Config File from the specified file.
-     * 
+     *
      * @param filename The name of the file to read/write
      */
     public ConfigFile(final String 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) {
 
     /**
      * Reads the data from the file.
-     * 
+     *
      * @throws IOException if an i/o exception occurred when reading
      * @throws InvalidConfigFileException if the config file isn't valid
      */
         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' || 
+
+            while (!tline.isEmpty() && (tline.charAt(0) == '\t' ||
                     tline.charAt(0) == ' ')) {
                 tline = tline.substring(1);
             }
 
                 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)) {
 
     /**
      * Writes the contents of this ConfigFile to disk.
-     * 
+     *
      * @throws IOException if the write operation fails
      */
     public void write() throws IOException {
             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.");
 
         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) {
             }
         }
     }
-    
+
     /**
      * 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
      */
             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
      */
     /**
      * 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
      */
     /**
      * 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
      */
 
     /**
      * 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
      */
                 } else {
                     temp.append(ch);
                 }
-                
+
                 escaped = false;
             } else if (ch == '\\') {
                 escaped = true;
                 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
      */
                 .replace("\r", "\\r").replace("=", "\\=")
                 .replace(":", "\\:").replace("#", "\\#");
     }
-    
+
     /**
      * 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;
                 return i;
             }
         }
-        
+
         return -1;
     }
 }

src/com/dmdirc/util/DownloadListener.java

 /**
  * Defines the method that objects interested in receiving download progress
  * updates should implement.
- * 
+ *
  * @author chris
  */
 public interface DownloadListener {
 
     /**
      * Called when the progress of the download has changed.
-     * 
+     *
      * @param percent The percentage of the file that has been downloaded
      */
     void downloadProgress(float percent);
-    
+
     /**
      * Called to notify the listener if this download has an indeterminate
      * length.
-     * 
+     *
      * @param indeterminate true or false
-     * 
+     *
      * @since 0.6
      */
     void setIndeterminate(final boolean indeterminate);

src/com/dmdirc/util/EquatableWeakReference.java

 /**
  * 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(final T referent) {
     public int hashCode() {
         return get().hashCode();
     }
-    
+
 }

src/com/dmdirc/util/InvalidConfigFileException.java

  * @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(final String string) {

src/com/dmdirc/util/ListenerList.java

 /**
  * 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 Map<Object, Collection<Object>> listeners
             = new HashMap<Object, Collection<Object>>();
-       
+
     /**
      * Adds a new listener of the specified type to this listener list.
-     * 
+     *
      * @param <T> The type of listener to be added
      * @param listenerType The type of listener to be added
      * @param listener The listener to be added
 
         listeners.get(listenerType).add(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
      */
 
         listeners.get(listenerType).add(listener);
     }
-    
+
     /**
      * Removes the specified listener from the list of listeners for the
      * specified type.
     public <T> void remove(final Class<T> listenerType, final T listener) {
         get(listenerType).remove(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) {
         get(listenerType).remove(listener);
     }
-    
+
     /**
      * Retrieves the list of listeners for the specified type.
      *
             return new CopyOnWriteArrayList<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
      */

src/com/dmdirc/util/ReturnableThread.java

 
 /**
  * Normal thread with the potential to return a value.
- * 
+ *
  * @param T Type to be returned
  */
 public abstract class ReturnableThread<T> extends Thread {
 
     /**
      * Sets the returnable object.
-     * 
+     *
      * @param value new returnable object
      */
     public void setObject(final T value) {
 
     /**
      * Returns the object set by this thread.
-     * 
+     *
      * @return Returnable object
      */
     public T getObject() {

src/com/dmdirc/util/RollingList.java

 /**
  * 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 
+ *
+ * @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 int position = 0;
     /** 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) {
     /**
      * 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;
 
     /**
      * 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.
 
     /**
      * Determines if this list is currently empty.
-     * 
+     *
      * @return True if the list is empty, false otherwise.
      */
     public boolean 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
      */
 
     /**
      * 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 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
      */
             items.remove(0);
             position--;
         }
-        
+
         return items.add(e);
     }
-    
+
     /**
      * Retrieves the current position within the list.
-     * 
+     *
      * @return This list's positional pointer
      */
     public int getPosition() {
 
     /**
      * Sets the positional pointer of this list.
-     * 
+     *
      * @param position The new position
      */
     public void setPosition(final 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() {
             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() {

src/com/dmdirc/util/StreamUtil.java

  * @author chris
  */
 public final class StreamUtil {
-    
+
     /** Shouldn't be called. */
     private StreamUtil() {
         super();

src/com/dmdirc/util/TextFile.java

 
 /**
  * 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) {
     /**
      * 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 = 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
      */
         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 {
             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
      */
             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();
 
     /**
      * 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.
      */
             throw new UnsupportedOperationException("Cannot delete TextFile "
                     + "opened with an InputStream");
         }
-        
+
         file.delete();
     }
 

src/com/dmdirc/util/WeakList.java

 /**
  * 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
  */
 
     /**
      * 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
      */
     /**
      * 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.

src/com/dmdirc/util/WeakMapList.java

  * 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
      */
         if (!map.containsKey(key)) {
             map.put(key, new WeakList<T>());
         }
-        
+
         return map.get(key);
     }
 }

src/com/dmdirc/util/validators/PermissiveValidator.java

  * @author chris
  */
 public class PermissiveValidator<V> implements Validator<V> {
-    
+
     /**
      * Creates a new instance of PermissiveValidator.
      */

src/com/dmdirc/util/validators/RegexStringValidator.java

 /*
  * Copyright (c) 2006-2011 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

src/com/dmdirc/util/validators/StringLengthValidator.java

 
 /**
  * Validates that the length of a string is within certain bounds.
- * 
+ *
  * @author chris
  */
 public class StringLengthValidator implements Validator<String> {
-    
+
     /** The minimum string length. */
     protected final int min;
-    
+
     /** The maximum string length. */
     protected final int max;