Style fixes

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

src/com/dmdirc/parser/common/CallbackObject.java

             for (Class<?> needed : ctor.getParameterTypes()) {
                 boolean found = false;
 
-                for (Class<?> source : sources.keySet()) {
-                    if (source.isAssignableFrom(needed)) {
-                        params[i] = sources.get(source);
+                for (Map.Entry<Class<?>, Object> entry : sources.entrySet()) {
+                    if (entry.getKey().isAssignableFrom(needed)) {
+                        params[i] = entry.getValue();
                         found = true;
                     }
                 }
 
-                if (!found && (param = getFakeArg(args, needed)) != null) {
-                    params[i] = param;
-                } else if (!found) {
-                    failed = true;
+                if (!found) {
+                    param = getFakeArg(args, needed);
+
+                    if (param != null) {
+                        params[i] = param;
+                    } else {
+                        failed = true;
+                    }
                 }
 
                 i++;

src/com/dmdirc/parser/common/MyInfo.java

 /*
  * 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
 
 /**
  * Contains User information.
- * 
+ *
  * @author Shane Mc Cormack
  * @author Chris Smith
  * @see IRCParser
 
     /**
      * Set the Nickname.
-     * 
+     *
      * @param newValue
      *            Value to set to.
      */
 
     /**
      * Get the Nickname.
-     * 
+     *
      * @return Current Nickname
      */
     public String getNickname() {
 
     /**
      * Set the Alternative Nickname.
-     * 
+     *
      * @param newValue
      *            Value to set to.
      */
 
     /**
      * Get the Alternative Nickname.
-     * 
+     *
      * @return Current Nickname
      */
     public String getAltNickname() {
 
     /**
      * Set the Realname.
-     * 
+     *
      * @param newValue
      *            Value to set to.
      */
 
     /**
      * Get the Realname.
-     * 
+     *
      * @return Current Realname
      */
     public String getRealname() {
 
     /**
      * Set the Username.
-     * 
+     *
      * @param newValue
      *            Value to set to.
      */
 
     /**
      * Get the Username.
-     * 
+     *
      * @return Current Username
      */
     public String getUsername() {
 
     /**
      * Set the Prepend Character.
-     * 
+     *
      * @param newValue
      *            Value to set to.
      */
 
     /**
      * Get the Prepend Character.
-     * 
+     *
      * @return Current Prepend Character
      */
     public char getPrependChar() {

src/com/dmdirc/parser/irc/IRCAuthenticator.java

     private static IRCAuthenticator me = null;
     
     /** List of authentication replies. */
-    private final Map<String,PasswordAuthentication> replies = new HashMap<String,PasswordAuthentication>();
+    private final Map<String, PasswordAuthentication> replies = new HashMap<String, PasswordAuthentication>();
 
     /** List of servers for each host. */
     private final Map<String, List<ServerInfo>> owners = new HashMap<String, List<ServerInfo>>();

src/com/dmdirc/parser/irc/IRCChannelClientInfo.java

 
 /**
  * Contains information about a client on a channel.
- * 
+ *
  * @author Shane Mc Cormack
  * @author Chris Smith
  * @see IRCParser
  */
 public class IRCChannelClientInfo implements ChannelClientInfo {
-    
+
     /** Reference to ClientInfo object this represents. */
     private final IRCClientInfo cClient;
     /** Integer representation of the channel modes assocated with this user. */
     private final ChannelInfo myChannel;
     /** A Map to allow applications to attach misc data to this object */
     private Map<Object, Object> myMap;
-    
+
     /**
      * Create a ChannelClient instance of a CLient.
      *
      * @param tParser Refernce to parser that owns this channelclient (used for modes)
      * @param client Client that this channelclient represents
      * @param channel Channel that owns this channelclient
-     */    
+     */
     public IRCChannelClientInfo(final IRCParser tParser, final IRCClientInfo client, final ChannelInfo channel) {
         myMap = new HashMap<Object, Object>();
         myParser = tParser;
         myChannel = channel;
         cClient.addChannelClientInfo(this);
     }
-    
+
     /**
      * Set the Map object attatched to this object.
      *
     public void setMap(final Map<Object, Object> newMap) {
         myMap = newMap;
     }
-    
+
     /** {@inheritDoc} */
         @Override
     public Map<Object, Object> getMap() { return myMap; }
-    
+
     /** {@inheritDoc} */
         @Override
     public IRCClientInfo getClient() { return cClient; }
      * Get the nickname of the client object represented by this channelclient.
      *
      * @return Nickname of the Client object represented by this channelclient
-     */    
-    public String getNickname() { return cClient.getNickname(); }    
-    
+     */
+    public String getNickname() { return cClient.getNickname(); }
+
     /**
      * Set the modes this client has (Prefix modes).
      *
      * @return integer representing the modes this client has.
      */
     public long getChanMode() { return nModes; }
-    
+
     /**
      * Get the modes this client has (Prefix modes) as a string.
      * Returns all known modes that the client has.
                 }
             }
         }
-        
+
         return sModes.toString();
     }
 
         }
         return 0;
     }
-    
+
     /** {@inheritDoc} */
         @Override
     public String getImportantMode() {
         if (!sModes.isEmpty()) { sModes = "" + sModes.charAt(0); }
         return sModes;
     }
-    
+
     /** {@inheritDoc} */
         @Override
     public String getImportantModePrefix() {
         if (!sModes.isEmpty()) { sModes = "" + sModes.charAt(0); }
         return sModes;
     }
-    
+
 
     /**
      * Get the String Value of ChannelClientInfo (ie @Nickname).
      * @return String Value of user (inc prefix) (ie @Nickname)
      */
     @Override
-    public String toString() { 
+    public String toString() {
         return this.getImportantModePrefix() + this.getNickname();
-    }    
-    
+    }
+
     /** {@inheritDoc} */
         @Override
     public void kick(final String sReason) {
         myParser.sendString("KICK " + myChannel + " " + this.getNickname() + (sReason.isEmpty() ? sReason : " :" + sReason));
     }
-    
+
     /**
      * Get the "Complete" String Value of ChannelClientInfo (ie @+Nickname).
      *

src/com/dmdirc/parser/irc/IRCChannelInfo.java

 
 /**
  * Contains Channel information.
- * 
+ *
  * @author Shane Mc Cormack
  * @author Chris Smith
  * @see IRCParser
      * When this is false, any new names reply will cause current known channelclients to be removed.
      */
     private boolean bAddingNames = true;
-    
+
     /** Unixtimestamp representing time when the channel was created. */
     private long nCreateTime = 0;
-    
+
     /** Current known topic in the channel. */
     private String sTopic = "";
     /** Last known user to set the topic (Full host where possible). */
     private long nTopicTime = 0;
     /** Has this channel ever had a topic? */
     private boolean hadTopic = false;
-    
+
     /** Known boolean-modes for channel. */
     private long nModes;
     /** Reference to the parser object that owns this channel, Used for modes. */
     private final IRCParser myParser; // Reference to parser object that owns this channel. Used for Modes
-    
+
     /** Channel Name. */
     private final String sName;
-    
+
     /** Hashtable containing references to ChannelClients. */
     private final Map<String, IRCChannelClientInfo> hChannelUserList = Collections.synchronizedMap(new Hashtable<String, IRCChannelClientInfo>());
     /** Hashtable storing values for modes set in the channel that use parameters. */
     private final List<String> lModeQueue = new LinkedList<String>();
     /** A Map to allow applications to attach misc data to this object */
     private Map<Object, Object> myMap;
-    
+
     /** Queue of requested list modes */
     private final Queue<Character> listModeQueue = new LinkedList<Character>();
     /** Listmode Queue Time */
     /**
      * Create a new channel object.
      *
-     * @param tParser Refernce to parser that owns this channelclient (used for modes)     
+     * @param tParser Refernce to parser that owns this channelclient (used for modes)
      * @param name Channel name.
      */
     public IRCChannelInfo(final IRCParser tParser, final String name) {
         myParser = tParser;
         sName = name;
     }
-    
+
     /**
      * Get the listModeQueue.
      *
         listModeQueueTime = now;
         return result;
     }
-    
+
     /**
      * Ask the server for all the list modes for this channel.
      */
     @Override
     public void requestListModes() {
         final IRCChannelClientInfo me = getChannelClient(myParser.getLocalClient());
-                
+
         if (me == null) {
             // In a normal situation of non bouncer-brokenness this won't happen
             return;
         }
-        
+
         askedForListModes = true;
-        
+
         final ServerType serverType = myParser.getServerType();
-                
+
         // We are considered opped if we have a mode higher than voice (or if we have any modes if voice doesn't exist)
         long voiceValue = 0;
-        if (myParser.prefixModes.get('v') != null) { voiceValue = myParser.prefixModes.get('v');}
+        if (myParser.prefixModes.get('v') != null) { voiceValue = myParser.prefixModes.get('v'); }
         final boolean isOpped = me.getImportantModeValue() > voiceValue;
-        
+
         int modecount = 1;
         if (serverType != ServerType.UNREAL && serverType != ServerType.IRSEE && myParser.h005Info.containsKey("MODES")) {
             try {
                 modecount = Integer.parseInt(myParser.h005Info.get("MODES"));
             } catch (NumberFormatException e) { /* use default modecount */}
         }
-        
+
         // Support for potential future decent mode listing in the protocol
         //
         // See my proposal: http://shane.dmdirc.com/listmodes.php
         // Add listmode handler
         final boolean supportLISTMODE = myParser.h005Info.containsKey("LISTMODE");
-        
+
         String listmodes = "";
         int i = 0;
         for (Character cTemp : myParser.chanModesOther.keySet()) {
         }
     }
 
-    
+
     /**
      * Has this channel ever had a topic? (even an empty one!)
-     * 
+     *
      * @return True if a topic has ever been known for this channel.
      */
     public synchronized boolean hadTopic() {
     public boolean hasAskedForListModes() {
         return askedForListModes;
     }
-    
+
     /**
      * Returns true if OnChannelGotListModes ever been called for this channel.
      *
     public boolean hasGotListModes() {
         return hasGotListModes;
     }
-    
+
     /**
      * Set if OnChannelGotListModes ever been called for this channel.
      *
     protected void setHasGotListModes(final boolean newValue) {
         hasGotListModes = newValue;
     }
-    
+
     /**
      * Set the Map object attatched to this object.
      *
     public void setMap(final Map<Object, Object> newMap) {
         myMap = newMap;
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public Map<Object, Object> getMap() {
         return myMap;
     }
-    
+
     /**
      * Set if we are getting a names request or not.
      *
      * @param newValue if false, any new names reply will cause current known channelclients to be removed.
      */
     public void setAddingNames(final boolean newValue) { bAddingNames = newValue; }
-    
+
     /**
      * Get if we are getting a names request or not.
      *
      * @return if false, any new names reply will cause current known channelclients to be removed.
      */
     public boolean isAddingNames() { return bAddingNames; }
-    
+
     /** {@inheritDoc} */
         @Override
     public String getName() { return sName; }
         /** {@inheritDoc} */
         @Override
     public int getChannelClientCount() { return hChannelUserList.size(); }
-    
+
     /** {@inheritDoc} */
         @Override
     public Collection<ChannelClientInfo> getChannelClients() {
             return new ArrayList<ChannelClientInfo>(hChannelUserList.values());
         }
     }
-    
+
     /**
      * Empty the channel (Remove all known channelclients).
      */
     public IRCChannelClientInfo getChannelClient(final String client) {
         return getChannelClient(client, false);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public IRCChannelClientInfo getChannelClient(final String client, final boolean create) {
             return null;
         }
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public IRCChannelClientInfo getChannelClient(final ClientInfo client) {
         }
         return null;
     }
-    
+
     /**
      * Get the ChannelClientInfo object associated with a ClientInfo object.
      *
      */
     protected IRCChannelClientInfo addClient(final IRCClientInfo cClient) {
         IRCChannelClientInfo cTemp = getChannelClient(cClient);
-        if (cTemp == null) { 
+        if (cTemp == null) {
             cTemp = new IRCChannelClientInfo(myParser, cClient, this);
             hChannelUserList.put(myParser.getStringConverter().toLowerCase(cTemp.getClient().getNickname()), cTemp);
         }
         return cTemp;
     }
-    
+
     /**
      * Remove ChannelClientInfo object associated with a ClientInfo object.
      *
      * @param cClient Client object to be removed from channel
-     */    
+     */
     protected void delClient(final IRCClientInfo cClient) {
         IRCChannelClientInfo cTemp = getChannelClient(cClient);
         if (cTemp != null) {
             }
             hChannelUserList.remove(myParser.getStringConverter().toLowerCase(cTemp.getClient().getNickname()));
         }
-    }    
-    
+    }
+
     /**
      * Rename a channelClient.
      *
      * @param oldNickname Nickname client used to be known as
      * @param cChannelClient ChannelClient object with updated client object
-     */    
+     */
     protected void renameClient(final String oldNickname, final IRCChannelClientInfo cChannelClient) {
         if (hChannelUserList.containsKey(oldNickname)) {
             final IRCChannelClientInfo cTemp = hChannelUserList.get(oldNickname);
             }
         }
     }
-    
+
     /**
      * Set the create time.
      *
      *
      * @return Unixtimestamp time for the channel creation (Seconds since epoch, not milliseconds)
      */
-    public long getCreateTime() { return nCreateTime; }    
-    
+    public long getCreateTime() { return nCreateTime; }
+
     /**
      * Set the topic time.
      *
 
         /** {@inheritDoc} */
         @Override
-    public long getTopicTime() { return nTopicTime; }    
-    
+    public long getTopicTime() { return nTopicTime; }
+
     /**
      * Set the topic.
      *
      * @param sNewTopic New contents of topic
-     */    
+     */
     protected void setInternalTopic(final String sNewTopic) { sTopic = sNewTopic; }
-    
+
         /** {@inheritDoc} */
         @Override
-    public String getTopic() { return sTopic; }    
+    public String getTopic() { return sTopic; }
 
     /**
      * Set the topic creator.
      *
      * @param sNewUser New user who set the topic (nickname if gotten on connect, full host if seen by parser)
-     */    
+     */
     protected void setTopicUser(final String sNewUser) { sTopicUser = sNewUser; }
-    
+
         /** {@inheritDoc} */
         @Override
     public String getTopicSetter() { return sTopicUser; }
-    
+
     /**
      * Set the channel modes (as an integer).
      *
      * @param nNewMode new long representing channel modes. (Boolean only)
-     */    
+     */
     protected void setMode(final long nNewMode) { nModes = nNewMode; }
     /**
      * Get the channel modes (as an integer).
      *
      * @return long representing channel modes. (Boolean only)
-     */    
-    public long getMode() { return nModes; }    
-    
+     */
+    public long getMode() { return nModes; }
+
     /** {@inheritDoc} */
         @Override
     public String getModes() {
                 sModeParams.append(" ").append(this.getMode(cTemp));
              }
         }
-        
+
         return sModes.append(sModeParams).toString();
-    }    
-    
+    }
+
     /**
      * Set a channel mode that requires a parameter.
      *
      * @param cMode Character representing mode
      * @param sValue String repreenting value (if "" mode is unset)
-     */    
-    protected void setModeParam(final Character cMode, final String sValue) { 
+     */
+    protected void setModeParam(final Character cMode, final String sValue) {
         if (sValue.isEmpty()) {
             if (hParamModes.containsKey(cMode)) {
                 hParamModes.remove(cMode);
             hParamModes.put(cMode, sValue);
         }
     }
-        
+
     /** {@inheritDoc} */
         @Override
     public String getMode(final char mode) {
         }
         return "";
     }
-    
+
     /**
      * Add/Remove a value to a channel list.
      *
      * @param givenItem ChannelListModeItem representing the item
      * @param bAdd Add or remove the value. (true for add, false for remove)
      */
-    protected void setListModeParam(final Character givenMode, final ChannelListModeItem givenItem, final boolean bAdd) { 
+    protected void setListModeParam(final Character givenMode, final ChannelListModeItem givenItem, final boolean bAdd) {
         Character cMode = givenMode;
         ChannelListModeItem newItem = givenItem;
         if (!myParser.chanModesOther.containsKey(cMode) || myParser.chanModesOther.get(cMode) != IRCParser.MODE_LIST) { return; }
-        
+
         // Hyperion sucks.
         if (cMode == 'b' || cMode == 'q') {
             final ServerType serverType = myParser.getServerType();
                 }
             }
         }
-        
-        if (!hListModes.containsKey(cMode)) { 
-            hListModes.put(cMode, new ArrayList<ChannelListModeItem>());    
+
+        if (!hListModes.containsKey(cMode)) {
+            hListModes.put(cMode, new ArrayList<ChannelListModeItem>());
         }
         final ArrayList<ChannelListModeItem> lModes = hListModes.get(cMode);
         for (int i = 0; i < lModes.size(); i++) {
             if (myParser.getStringConverter().equalsIgnoreCase(lModes.get(i).getItem(), newItem.getItem())) {
                 if (bAdd) { return; }
-                else { 
+                else {
                     lModes.remove(i);
                     break;
                 }
         }
         if (bAdd) { lModes.add(newItem); }
     }
-    
+
     /** {@inheritDoc} */
         @Override
     public Collection<ChannelListModeItem> getListMode(final char mode) {
         if (!myParser.chanModesOther.containsKey(mode) || myParser.chanModesOther.get(mode) != IRCParser.MODE_LIST) { return null; }
-        
+
         if (!hListModes.containsKey(mode)) {
             hListModes.put(mode, new ArrayList<ChannelListModeItem>());
         }
         return hListModes.get(mode);
     }
-    
+
     /**
      * Get the "adding state" of a list mode.
-     * 
-     * @param cMode Character representing mode 
+     *
+     * @param cMode Character representing mode
      * @return false if we are not expecting a 367 etc, else true.
      */
-    public boolean getAddState(final Character cMode) { 
+    public boolean getAddState(final Character cMode) {
         synchronized (lAddingModes) {
             return lAddingModes.contains(cMode);
         }
     }
-    
+
     /**
      * Get the "adding state" of a list mode.
-     * 
+     *
      * @param cMode Character representing mode
      * @param newState change the value returned by getAddState
      */
-    protected void setAddState(final Character cMode, final boolean newState) { 
+    protected void setAddState(final Character cMode, final boolean newState) {
         synchronized (lAddingModes) {
             if (newState) {
                 lAddingModes.add(cMode);
             }
         }
     }
-    
+
     /**
      * Reset the "adding state" of *all* list modes.
      */
             lAddingModes.clear();
         }
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void alterMode(final boolean add, final Character mode, final String parameter) {
         String modestr = "";
         if (myParser.h005Info.containsKey("MODES")) {
             try {
-                modecount = Integer.parseInt(myParser.h005Info.get("MODES")); 
+                modecount = Integer.parseInt(myParser.h005Info.get("MODES"));
             } catch (NumberFormatException e) {
                 if (myParser.getServerType() == ServerType.OTHERNET) {
                     modecount = 6;
                         final String existingParam = getMode(mode);
                         if (!existingParam.isEmpty()) {
                             final String reverseModeStr = "-" + mode + " " + existingParam;
-                            
+
                             myParser.callDebugInfo(IRCParser.DEBUG_INFO, "Queueing mode: %s", reverseModeStr);
                             lModeQueue.add(reverseModeStr);
                             if (lModeQueue.size() == modecount) { flushModes(); }
         lModeQueue.add(modestr);
         if (lModeQueue.size() == modecount) { flushModes(); }
     }
-    
+
     /** {@inheritDoc} */
         @Override
     public void flushModes() {
         myParser.sendRawMessage("MODE " + sName + " " + sendModeStr.toString());
         clearModeQueue();
     }
-    
+
     /**
      * This function will clear the mode queue (WITHOUT Sending).
      */
-    public void clearModeQueue() { 
+    public void clearModeQueue() {
         lModeQueue.clear();
     }
-    
+
     /** {@inheritDoc} */
         @Override
     public void sendMessage(final String message) {
         if (message.isEmpty()) { return; }
-        
+
         myParser.sendString("PRIVMSG " + sName + " :" + message);
     }
-    
+
     /**
      * Send a notice message to a target.
      *
      * @param sMessage Message to send
      */
-    public void sendNotice(final String sMessage) { 
+    public void sendNotice(final String sMessage) {
         if (sMessage.isEmpty()) { return; }
-        
-        myParser.sendString("NOTICE " + sName + " :" + sMessage);    
+
+        myParser.sendString("NOTICE " + sName + " :" + sMessage);
     }
 
     /** {@inheritDoc} */
         if (action.isEmpty()) { return; }
         sendCTCP("ACTION", action);
     }
-    
+
     /**
      * Send a CTCP to a target.
      *
      * @param sType Type of CTCP
      * @param sMessage Optional Additional Parameters
      */
-    public void sendCTCP(final String sType, String sMessage) { 
+    public void sendCTCP(final String sType, String sMessage) {
         if (sType.isEmpty()) { return; }
         final char char1 = (char) 1;
         if (!sMessage.isEmpty()) { sMessage = " " + sMessage; }
         sendMessage(char1 + sType.toUpperCase() + sMessage + char1);
     }
-    
+
     /**
      * Send a CTCPReply to a target.
      *
      * @param sType Type of CTCP
      * @param sMessage Optional Additional Parameters
      */
-    public void sendCTCPReply(final String sType, String sMessage) { 
+    public void sendCTCPReply(final String sType, String sMessage) {
         if (sType.isEmpty()) { return; }
         final char char1 = (char) 1;
         if (!sMessage.isEmpty()) { sMessage = " " + sMessage; }
-        sendNotice(char1 + sType.toUpperCase() + sMessage + char1);    
+        sendNotice(char1 + sType.toUpperCase() + sMessage + char1);
     }
-    
+
     /**
      * Get a string representation of the Channel.
      *
      */
     @Override
     public String toString() { return sName; }
-    
+
     /** {@inheritDoc} */
         @Override
     public Parser getParser() { return myParser; }

src/com/dmdirc/parser/irc/IRCClientInfo.java

 
 /**
  * Contains information about known users.
- * 
+ *
  * @author Shane Mc Cormack
  * @author Chris Smith
  * @see IRCParser
     /** Known nickname of client. */
     private String sNickname = "";
     /** Known ident of client. */
-    private String sIdent = "";    
+    private String sIdent = "";
     /** Known host of client. */
     private String sHost = "";
     /** Known user modes of client. */
     public void setMap(final Map<Object, Object> newMap) {
         myMap = newMap;
     }
-    
+
     /** {@inheritDoc} */
         @Override
     public Map<Object, Object> getMap() {
         // Get the nickname from the string.
         return parseHostFull(sWho)[0];
     }
-    
+
     /**
      * Get a nick ident and host of a user from a hostmask.
      * Hostmask must match (?:)nick(?!ident)(?@host)
         sTemp = sTemp[0].split("!", 2);
         if (sTemp.length == 1) { result[1] = ""; } else { result[1] = sTemp[1]; }
         result[0] = sTemp[0];
-        
+
         return result;
     }
 
      *
      * @param sHostmask takes a host (?:)nick(?!ident)(?@host) and sets nick/host/ident variables
      * @param bUpdateNick if this is false, only host/ident will be updated.
-     */    
+     */
     public void setUserBits(final String sHostmask, final boolean bUpdateNick) {
         setUserBits(sHostmask, bUpdateNick, false);
     }
-    
+
     /**
      * Set the nick/ident/host of this client.
      *
      * @param bUpdateNick if this is false, only host/ident will be updated.
      * @param allowBlank if this is true, ident/host will be set even if
      *                   parseHostFull returns empty values for them
-     */    
+     */
     public void setUserBits(final String sHostmask, final boolean bUpdateNick, final boolean allowBlank) {
         final String[] sTemp = parseHostFull(sHostmask);
         if (!sTemp[2].isEmpty() || allowBlank) { sHost = sTemp[2]; }
         if (!sTemp[1].isEmpty() || allowBlank) { sIdent = sTemp[1]; }
         if (bUpdateNick) { sNickname = sTemp[0]; }
     }
-    
+
     /**
      * Get a string representation of the user.
      *
      */
     @Override
     public String toString() { return sNickname + "!" + sIdent + "@" + sHost; }
-    
+
     /** {@inheritDoc} */
     @Override
     public String getNickname() {
             return sNickname;
         }
     }
-    
+
     /** {@inheritDoc} */
     public String getRealNickname() { return sNickname; }
-    
+
     /** {@inheritDoc} */
     @Override
     public String getUsername() { return sIdent; }
-    
+
     /** {@inheritDoc} */
   @Override
     public String getHostname() { return sHost; }
-    
+
     /**
      * Set the away state of a user.
      * Automatically sets away reason to "" if not set to AwayState.AWAY
      *
      * @param bNewState AwayState representing new away state.
-     */    
+     */
     protected void setAwayState(final AwayState bNewState) {
         away = bNewState;
         if (away != AwayState.AWAY) { myAwayReason = ""; }
     }
-    
+
     /**
      * Get the away state of a user.
      *
      * @return AwayState of the user.
-     */    
+     */
     public AwayState getAwayState() { return away; }
-    
+
     /**
      * Get the Away Reason for this user.
      *
      * @return Known away reason for user.
      */
     public String getAwayReason() { return myAwayReason; }
-    
+
     /**
      * Set the Away Reason for this user.
      * Automatically set to "" if awaystate is set to false
      * @param newValue new away reason for user.
      */
     protected void setAwayReason(final String newValue) { myAwayReason = newValue; }
-    
+
     /** {@inheritDoc} */
         @Override
     public String getRealname() { return sRealName; }
-    
+
     /**
      * Set the RealName for this user.
      *
      * @param newValue new RealName for user.
      */
     protected void setRealName(final String newValue) { sRealName = newValue; }
-    
+
     /**
      * Set the user modes (as an integer).
      *
      * @param nNewMode new long representing channel modes. (Boolean only)
-     */    
+     */
     protected void setUserMode(final long nNewMode) { nModes = nNewMode; }
-    
+
     /**
      * Get the user modes (as an integer).
      *
      * @return long representing channel modes. (Boolean only)
-     */    
-    public long getUserMode() { return nModes; }    
-    
+     */
+    public long getUserMode() { return nModes; }
+
     /** {@inheritDoc} */
         @Override
     public String getModes() {
         final StringBuilder sModes = new StringBuilder("+");
         long nTemp = 0;
         final long nChanModes = this.getUserMode();
-        
+
         for (char cTemp : myParser.userModes.keySet()) {
             nTemp = myParser.userModes.get(cTemp);
             if ((nChanModes & nTemp) == nTemp) { sModes.append(cTemp); }
         }
-        
+
         return sModes.toString();
     }
-    
+
     /**
      * Is this client an oper?
      * This is a guess currently based on user-modes and thus only works on the
         final String modestr = getModes();
         return (modestr.indexOf('o') > -1) || (modestr.indexOf('O') > -1);
     }
-    
+
     /**
      * Add a ChannelClientInfo as a known reference to this client.
      *
      * @param cci ChannelClientInfo to add as a known reference
-     */    
+     */
     public void addChannelClientInfo(final IRCChannelClientInfo cci) {
         final String key = myParser.getStringConverter().toLowerCase(cci.getChannel().getName());
         if (!myChannelClientInfos.containsKey(key)) {
             myChannelClientInfos.put(key, cci);
         }
     }
-    
+
     /**
      * Remove a ChannelClientInfo as a known reference to this client.
      *
      * @param cci ChannelClientInfo to remove as a known reference
-     */    
+     */
     public void delChannelClientInfo(final IRCChannelClientInfo cci) {
         final String key = myParser.getStringConverter().toLowerCase(cci.getChannel().getName());
         if (myChannelClientInfos.containsKey(key)) {
             myChannelClientInfos.remove(key);
         }
     }
-    
+
     /**
      * Check to see if a client is still known on any of the channels we are on.
      *
     public boolean checkVisibility() {
         return !myChannelClientInfos.isEmpty();
     }
-    
+
     /** {@inheritDoc} */
         @Override
     public int getChannelCount() {
         return myChannelClientInfos.size();
     }
-    
+
     /**
      * Get a list of channelClients that point to this object.
      *
      * @return int with the count of known channels
-     */    
+     */
     public List<IRCChannelClientInfo> getChannelClients() {
         final List<IRCChannelClientInfo> result = new ArrayList<IRCChannelClientInfo>();
         for (IRCChannelClientInfo cci : myChannelClientInfos.values()) {
         }
         return result;
     }
-    
+
     /** {@inheritDoc} */
         @Override
     public void alterMode(final boolean add, final Character mode) {
         int modecount = 1;
         String modestr = "";
         if (myParser.h005Info.containsKey("MODES")) {
-            try { 
-                modecount = Integer.parseInt(myParser.h005Info.get("MODES")); 
-            } catch (NumberFormatException e) { 
+            try {
+                modecount = Integer.parseInt(myParser.h005Info.get("MODES"));
+            } catch (NumberFormatException e) {
                 modecount = 1;
             }
         }
         lModeQueue.add(modestr);
         if (lModeQueue.size() == modecount) { flushModes(); }
     }
-    
+
     /** {@inheritDoc} */
         @Override
     public void flushModes() {
         myParser.sendRawMessage("MODE " + sNickname + " " + sendModeStr.toString());
         clearModeQueue();
     }
-    
+
     /**
      * This function will clear the mode queue (WITHOUT Sending).
      */
-    public void clearModeQueue() { 
+    public void clearModeQueue() {
         lModeQueue.clear();
     }
-    
+
     /** {@inheritDoc} */
         @Override
     public Parser getParser() { return myParser; }

src/com/dmdirc/parser/irc/IRCParser.java

 
         currentSocketState = SocketState.CLOSED;
         // Char Mapping
-        updateCharArrays((byte)4);
+        updateCharArrays((byte) 4);
     }
 
     /**
             final IRCChannelInfo channel = getChannel(newLine[1]);
             if (channel != null) {
                 final Queue<Character> listModeQueue = channel.getListModeQueue();
-                for (int i = 0; i < newLine[2].length() ; ++i) {
+                for (int i = 0; i < newLine[2].length(); ++i) {
                     final Character mode = newLine[2].charAt(i);
                     callDebugInfo(DEBUG_LMQ, "Intercepted mode request for "+channel+" for mode "+mode);
                     if (chanModesOther.containsKey(mode) && chanModesOther.get(mode) == MODE_LIST) {
                             break;
                         default: // Unknown - Send to Notice Auth
                             // Some networks send a CTCP during the auth process, handle it
-                            if (token.length > 3 && !token[3].isEmpty() && token[3].charAt(0) == (char)1 && token[3].charAt(token[3].length()-1) == (char)1) {
+                            if (token.length > 3 && !token[3].isEmpty() && token[3].charAt(0) == (char) 1 && token[3].charAt(token[3].length()-1) == (char) 1) {
                                 try { myProcessingManager.process(sParam, token); } catch (ProcessorNotFoundException e) { }
                                 break;
                             }
         @Override
     public IRCStringConverter getStringConverter() {
         if (stringConverter == null) {
-            stringConverter = new IRCStringConverter((byte)4);
+            stringConverter = new IRCStringConverter((byte) 4);
         }
         return stringConverter;
     }
             // nTemp should never be less than 0
             if (nTemp > 0) {
                 pos = Math.log(nTemp) / Math.log(2);
-                modes[(int)pos] = cTemp;
+                modes[(int) pos] = cTemp;
             }
 /*            // Is there an easier way to find out the power of 2 value for a number?
             // ie 1024 = 10, 512 = 9 ?
      * @param client Client to add
      */
     public void addClient(final IRCClientInfo client) {
-        clientList.put(getStringConverter().toLowerCase(client.getRealNickname()),client);
+        clientList.put(getStringConverter().toLowerCase(client.getRealNickname()), client);
     }
 
     /**

src/com/dmdirc/parser/irc/IRCStringConverter.java

      * Create a new IRCStringConverter with rfc1459 encoding.
      */
     public IRCStringConverter() {
-        this((byte)4);
+        this((byte) 4);
     }
     
     /**
      */
     public IRCStringConverter(final byte limit) {
         // If limit is out side the boundries, use rfc1459
-        if (limit > 4 || limit < 0) { this.limit = (byte)4; }
+        if (limit > 4 || limit < 0) { this.limit = (byte) 4; }
         else { this.limit = limit; }
         
         lowercase = new char[127];
 
         // Replace the uppercase chars with lowercase
         for (char i = 65; i <= (90 + this.limit); ++i) {
-            lowercase[i] = (char)(i + 32);
+            lowercase[i] = (char) (i + 32);
             uppercase[i + 32] = i;
         }
     }

src/com/dmdirc/parser/irc/Logging.java

         WARN("warn", "isWarnEnabled"),
         ERROR("error", "isErrorEnabled"),
         FATAL("fatal", "isFatalEnabled");
-        
+
         /** Method name */
         private final String methodName;
-        
+
         /** Check Method name */
         private final String checkMethodName;
-        
+
         /**
          * Create a new LogLevel
          *
             this.methodName = methodName;
             this.checkMethodName = checkMethodName;
         }
-        
+
         /**
          * Get the Name of method in log4j to log to
          *
          * @return Name of method in log4j to log to
          */
         public String getMethodName() { return methodName; }
-        
+
         /**
          * Get the Name of the check method in log4j
          *
          */
         public String getCheckMethodName() { return checkMethodName; }
     };
-    
+
     /** Singleton Instance of Logging. */
     private static Logging me;
-    
+
     /** Is log4j available. */
     private final boolean isAvailable;
-    
+
     /** "Log" object if available. */
     private Object log = null;
-    
+
     /**
      * Get an instance of Logging.
      *
         if (me == null) { me = new Logging(); }
         return me;
     }
-    
+
     /** Create a new Logging. */
     @SuppressWarnings("unchecked")
     private Logging() {
             // Check for classes
             Class.forName("org.apache.commons.logging.Log");
             factory = Class.forName("org.apache.commons.logging.LogFactory");
-        
+
             classExists = (factory != null);
             if (classExists) {
                 final Method getLog = factory.getMethod("getLog", new Class[]{Class.class});
         } catch (IllegalAccessException iae) {
         } catch (InvocationTargetException ite) {
         }
-        
+
         isAvailable = (classExists && log != null);
     }
-    
+
     /**
      * Check is a log level is available.
      *
         if (isAvailable) {
             try {
                 final Method check = log.getClass().getMethod(level.getCheckMethodName(), new Class[0]);
-                return (Boolean)check.invoke(log, new Object[0]);
+                return (Boolean) check.invoke(log, new Object[0]);
             } catch (NoSuchMethodException nsme) {
             } catch (IllegalAccessException iae) {
             } catch (InvocationTargetException ite) {
             }
         }
-        
+
         return false;
     }
-    
+
     /**
      * Log a message if log4j is available.
      *
     public void log(final LogLevel level, final String message) {
         log(level, message, null);
     }
-    
+
     /**
      * Log a message if log4j is available.
      *

src/com/dmdirc/parser/irc/Process001.java

     public void process(final String sParam, final String[] token) {
         myParser.got001 = true;
         // << :demon1.uk.quakenet.org 001 Java-Test :Welcome to the QuakeNet IRC Network, Java-Test
-        myParser.serverName = token[0].substring(1,token[0].length());
+        myParser.serverName = token[0].substring(1, token[0].length());
         final String sNick = token[2];
 
         // myself will be fake if we havn't recieved a 001 yet

src/com/dmdirc/parser/irc/Process004005.java

                 myParser.h005Info.put("002IRCD", matcher.group(1));
             }
         } else if (sParam.equals("003")) {
-            myParser.h005Info.put("003IRCD",token[token.length-1]);
+            myParser.h005Info.put("003IRCD", token[token.length-1]);
         } else if (sParam.equals("004")) {
             // 004
             if (token.length > 4) {
-                myParser.h005Info.put("004IRCD",token[4]);
-                myParser.h005Info.put("USERMODES",token[5]);
-                myParser.h005Info.put("USERCHANMODES",token[6]);
-                if (token.length > 7) { myParser.h005Info.put("USERCHANPARAMMODES",token[7]); } // INSPIRCD includes an extra param
+                myParser.h005Info.put("004IRCD", token[4]);
+                myParser.h005Info.put("USERMODES", token[5]);
+                myParser.h005Info.put("USERCHANMODES", token[6]);
+                if (token.length > 7) { myParser.h005Info.put("USERCHANPARAMMODES", token[7]); } // INSPIRCD includes an extra param
             } else {
                 final String[] bits = token[3].split(" ");
-                myParser.h005Info.put("004IRCD",bits[1]);
-                myParser.h005Info.put("USERMODES",bits[2]);
-                myParser.h005Info.put("USERCHANMODES",bits[3]);
-                if (token.length > 4) { myParser.h005Info.put("USERCHANPARAMMODES",bits[4]); } // INSPIRCD includes an extra param
+                myParser.h005Info.put("004IRCD", bits[1]);
+                myParser.h005Info.put("USERMODES", bits[2]);
+                myParser.h005Info.put("USERCHANMODES", bits[3]);
+                if (token.length > 4) { myParser.h005Info.put("USERCHANPARAMMODES", bits[4]); } // INSPIRCD includes an extra param
             }
             myParser.parseUserModes();
         } else if (sParam.equals("005")) {
             // 005
-            for (int i = 3; i < token.length ; i++) {
-                String[] bits = token[i].split("=",2);
+            for (int i = 3; i < token.length; i++) {
+                String[] bits = token[i].split("=", 2);
                 if (bits[0].isEmpty()) { continue; }
                 final boolean isNegation = (bits[0].charAt(0) == '-');
                 final String sKey = (isNegation) ? bits[0].substring(1).toUpperCase() : bits[0].toUpperCase();
                 final String sValue = (bits.length == 2) ? bits[1] : "";
-                callDebugInfo(IRCParser.DEBUG_INFO, "%s => %s",sKey,sValue);
+                callDebugInfo(IRCParser.DEBUG_INFO, "%s => %s", sKey, sValue);
                 if (isNegation) {
                     myParser.h005Info.remove(sKey);
                 } else {
-                    myParser.h005Info.put(sKey,sValue);
+                    myParser.h005Info.put(sKey, sValue);
                 }
                 if (sKey.equals("NETWORK") && !isNegation) {
                     myParser.networkName = sValue;
                     callGotNetwork();
                 } else if (sKey.equals("CASEMAPPING") && !isNegation) {
-                    byte limit = (byte)4;
+                    byte limit = (byte) 4;
                     if (sValue.equalsIgnoreCase("strict-rfc1459")) {
-                        limit = (byte)3;
+                        limit = (byte) 3;
                     } else if (sValue.equalsIgnoreCase("ascii")) {
-                        limit = (byte)0;
+                        limit = (byte) 0;
                     } else if (!sValue.equalsIgnoreCase("rfc1459")) {
                         myParser.callErrorInfo(new ParserError(ParserError.ERROR_WARNING, "Unknown casemapping: '"+sValue+"' - assuming rfc1459", myParser.getLastLine()));
                     }

src/com/dmdirc/parser/irc/ProcessAway.java

             if (iClient != null) { iClient.setAwayReason(token[token.length-1]); }
         } else {
             final AwayState oldState = myParser.getLocalClient().getAwayState();
-            myParser.getLocalClient().setAwayState(sParam.equals("306") ? AwayState.AWAY : AwayState.HERE) ;
+            myParser.getLocalClient().setAwayState(sParam.equals("306") ? AwayState.AWAY : AwayState.HERE);
             callAwayState(oldState, myParser.getLocalClient().getAwayState(), myParser.getLocalClient().getAwayReason());
         }
     }

src/com/dmdirc/parser/irc/ProcessJoin.java

                 myParser.addClient(iClient);
             }
             // Check to see if we know the host/ident for this client to facilitate dmdirc Formatter
-            if (iClient.getHostname().isEmpty()) { iClient.setUserBits(token[0],false); }
+            if (iClient.getHostname().isEmpty()) { iClient.setUserBits(token[0], false); }
             if (iChannel != null) {
                 if (iClient == myParser.getLocalClient()) {
                     try {

src/com/dmdirc/parser/irc/ProcessKick.java

         
         if (IRCParser.ALWAYS_UPDATECLIENT && iKicker != null) {
             // To facilitate dmdirc formatter, get user information
-            if (iKicker.getHostname().isEmpty()) { iKicker.setUserBits(token[0],false); }
+            if (iKicker.getHostname().isEmpty()) { iKicker.setUserBits(token[0], false); }
         }
 
         if (iChannel == null) { 
                 return;
             }
             iChannelKicker = iChannel.getChannelClient(token[0]);
-            if (myParser.removeAfterCallback) { callChannelKick(iChannel,iChannelClient,iChannelKicker,sReason,token[0]); }
+            if (myParser.removeAfterCallback) { callChannelKick(iChannel, iChannelClient, iChannelKicker, sReason, token[0]); }
             iChannel.delClient(iClient);
-            if (!myParser.removeAfterCallback) { callChannelKick(iChannel,iChannelClient,iChannelKicker,sReason,token[0]); }
+            if (!myParser.removeAfterCallback) { callChannelKick(iChannel, iChannelClient, iChannelKicker, sReason, token[0]); }
             if (iClient == myParser.getLocalClient()) {
                 iChannel.emptyChannel();
                 myParser.removeChannel(iChannel);

src/com/dmdirc/parser/irc/ProcessListModes.java

                     // Only raise an LMQ error if the lmqmode isn't one of bdq if the
                     // guess is one of bdq
                     if (ServerTypeGroup.FREENODE.isMember(serverType) && (mode == 'b' || mode == 'q' || mode == 'd')) {
-                        LinkedList<Character> lmq = (LinkedList<Character>)listModeQueue;
+                        LinkedList<Character> lmq = (LinkedList<Character>) listModeQueue;
                         if (mode == 'b') {
                             error = !(oldMode == 'q' || oldMode == 'd');
-                            lmq.remove((Character)'q');
+                            lmq.remove((Character) 'q');
                             myParser.callDebugInfo(IRCParser.DEBUG_LMQ, "Dropping q from list");
                         } else if (mode == 'q') {
                             error = !(oldMode == 'b' || oldMode == 'd');
-                            lmq.remove((Character)'b');
+                            lmq.remove((Character) 'b');
                             myParser.callDebugInfo(IRCParser.DEBUG_LMQ, "Dropping b from list");
                         } else if (mode == 'd') {
                             error = !(oldMode == 'b' || oldMode == 'q');
             if (token.length > tokenStart) { item = token[tokenStart]; }
             if (!item.isEmpty()) {
                 ChannelListModeItem clmi = new ChannelListModeItem(item, owner, time);
-                callDebugInfo(IRCParser.DEBUG_INFO, "List Mode: %c [%s/%s/%d]",mode, item, owner, time);
+                callDebugInfo(IRCParser.DEBUG_INFO, "List Mode: %c [%s/%s/%d]", mode, item, owner, time);
                 channel.setListModeParam(mode, clmi, true);
             }
         } else {
             callDebugInfo(IRCParser.DEBUG_INFO, "List Mode Batch over");
             channel.resetAddState();
-            if (isCleverMode || listModeQueue == null || ((LinkedList<Character>)listModeQueue).size() == 0) {
+            if (isCleverMode || listModeQueue == null || ((LinkedList<Character>) listModeQueue).size() == 0) {
                 callDebugInfo(IRCParser.DEBUG_INFO, "Calling GotListModes");
                 channel.setHasGotListModes(true);
 

src/com/dmdirc/parser/irc/ProcessMessage.java

              pe.setException(pse);
              callErrorInfo(pe);
         }
-        
+
         // Lines such as:
         // "nick!user@host PRIVMSG"
         // are invalid, stop processing.
         if (token.length < 3) { return; }
-        
+
         // Is this actually a notice auth?
         if (token[0].indexOf('!') == -1 && token[1].equalsIgnoreCase("NOTICE") && token[2].equalsIgnoreCase("AUTH")) {
             try {
             } catch (ProcessorNotFoundException e) { }
             return;
         }
-        
+
         IRCChannelClientInfo iChannelClient = null;
         IRCChannelInfo iChannel = null;
         IRCClientInfo iClient = null;
             sMessage = token[token.length-1];
         }
         String[] bits = sMessage.split(" ", 2);
-        final Character char1 = Character.valueOf((char)1);
+        final Character char1 = Character.valueOf((char) 1);
         String sCTCP = "";
         boolean isAction = false;
         boolean isCTCP = false;
-        
+
         if (sMessage.length() > 1) {
             if (sParam.equalsIgnoreCase("PRIVMSG")) {
                 // Actions are special CTCPs
                     // Some CTCPs have messages and some do not
                     if (bits.length > 1) { sMessage = bits[1]; } else { sMessage = ""; }
                     // Remove the leading char1
-                    bits = bits[0].split(char1.toString(),2);
+                    bits = bits[0].split(char1.toString(), 2);
                     sCTCP = bits[1];
                     // remove the trailing char1
-                    if (!sMessage.isEmpty()) { sMessage = sMessage.split(char1.toString(),2)[0]; }
-                    else { sCTCP = sCTCP.split(char1.toString(),2)[0]; }
-                    callDebugInfo(IRCParser.DEBUG_INFO, "CTCP: \"%s\" \"%s\"",sCTCP,sMessage);
+                    if (!sMessage.isEmpty()) { sMessage = sMessage.split(char1.toString(), 2)[0]; }
+                    else { sCTCP = sCTCP.split(char1.toString(), 2)[0]; }
+                    callDebugInfo(IRCParser.DEBUG_INFO, "CTCP: \"%s\" \"%s\"", sCTCP, sMessage);
                 }
             }
         }
         iClient = getClientInfo(token[0]);
         if (IRCParser.ALWAYS_UPDATECLIENT && iClient != null) {
             // Facilitate DMDIRC Formatter
-            if (iClient.getHostname().isEmpty()) {iClient.setUserBits(token[0],false); }
+            if (iClient.getHostname().isEmpty()) {iClient.setUserBits(token[0], false); }
         }
-        
+
         // Fire the appropriate callbacks.
         // OnChannel* Callbacks are fired if the target was a channel
         // OnPrivate* Callbacks are fired if the target was us
         // OnUnknown* Callbacks are fired if the target was neither of the above
         // Actions and CTCPs are send as PRIVMSGS
         // CTCPReplies are sent as Notices
-        
+
         // Check if we have a Mode Prefix for channel targets.
         // Non-Channel messages still use the whole token, even if the first char
         // is a prefix.
         final char modePrefix = token[2].charAt(0);
         final boolean hasModePrefix =  (myParser.prefixMap.containsKey(modePrefix) && !myParser.prefixModes.containsKey(modePrefix));
         final String targetName = (hasModePrefix) ? token[2].substring(1) : token[2];
-        
+
         if (isValidChannelName(targetName)) {
             iChannel = getChannel(targetName);
             if (iChannel == null) {
             }
         }
     }
-    
+
     /**
      * Callback to all objects implementing the ChannelAction Callback.
      *
     protected boolean callChannelAction(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
         return getCallbackManager().getCallbackType(ChannelActionListener.class).call(cChannel, cChannelClient, sMessage, sHost);
     }
-    
+
     /**
      * Callback to all objects implementing the ChannelCTCP Callback.
      *
     protected boolean callChannelCTCPReply(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sType, final String sMessage, final String sHost) {
         return getCallbackManager().getCallbackType(ChannelCtcpReplyListener.class).call(cChannel, cChannelClient, sType, sMessage, sHost);
     }
-    
+
     /**
      * Callback to all objects implementing the ChannelMessage Callback.
      *
     protected boolean callChannelMessage(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
         return getCallbackManager().getCallbackType(ChannelMessageListener.class).call(cChannel, cChannelClient, sMessage, sHost);
     }
-    
+
     /**
      * Callback to all objects implementing the ChannelNotice Callback.
      *
     protected boolean callChannelNotice(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
         return getCallbackManager().getCallbackType(ChannelNoticeListener.class).call(cChannel, cChannelClient, sMessage, sHost);
     }
-    
+
     /**
      * Callback to all objects implementing the ChannelModeNotice Callback.
      *
     protected boolean callChannelModeNotice(final char prefix, final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
         return getCallbackManager().getCallbackType(ChannelModeNoticeListener.class).call(cChannel, prefix, cChannelClient, sMessage, sHost);
     }
-    
+
     /**
      * Callback to all objects implementing the ChannelModeMessage Callback.
      *
     protected boolean callChannelModeMessage(final char prefix, final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
         return getCallbackManager().getCallbackType(ChannelModeMessageListener.class).call(cChannel, prefix, cChannelClient, sMessage, sHost);
     }
-    
+
     /**
      * Callback to all objects implementing the PrivateAction Callback.
      *
     protected boolean callServerNotice(final String sMessage, final String sHost) {
         return getCallbackManager().getCallbackType(ServerNoticeListener.class).call(sMessage, sHost);
     }
-    
+
     /**
      * Callback to all objects implementing the UnknownAction Callback.
      *
         return getCallbackManager().getCallbackType(UnknownServerNoticeListener.class).call(sMessage, sTarget, sHost);
     }
 
-    
+
     /**
      * What does this IRCProcessor handle.
      *
     public String[] handles() {
         return new String[]{"PRIVMSG", "NOTICE"};
     }
-    
+
     /**
      * Create a new instance of the IRCProcessor Object.
      *

src/com/dmdirc/parser/irc/ProcessMode.java

         if (!isValidChannelName(sChannelName)) { processUserMode(sParam, token, sModestr, false); }
         else { processChanMode(sParam, token, sModestr, sChannelName); }
     }
-    
+
     /**
      * Method to trim spaces from strings
      *
      * @return String without spaces on the ends
      */
     private String trim(String str) { return str.trim(); }
-    
+
     /**
      * Process Chan modes.
      *
      * @param token IRCTokenised Array of the incomming line
      * @param sModestr The modes and params
      * @param sChannelName Channel these modes are for
-     */    
+     */
     public void processChanMode(String sParam, String[] token, String[] sModestr, String sChannelName) {
         StringBuilder sFullModeStr = new StringBuilder();
         String sNonUserModeStr = "";
         IRCChannelClientInfo iChannelClientInfo;
         IRCClientInfo iClient;
         IRCChannelClientInfo setterCCI;
-        
+
         CallbackObject cbSingle = null;
         CallbackObject cbNonUser = null;
 
             cbSingle = getCallbackManager().getCallbackType(ChannelSingleModeChangeListener.class);
             cbNonUser = getCallbackManager().getCallbackType(ChannelNonUserModeChangeListener.class);
         }
-        
+
         iChannel = getChannel(sChannelName);
-        if (iChannel == null) { 
+        if (iChannel == null) {
             // callErrorInfo(new ParserError(ParserError.ERROR_WARNING, "Got modes for channel ("+sChannelName+") that I am not on.", myParser.getLastLine()));
             // iChannel = new ChannelInfo(myParser, sChannelName);
             // myParser.addChannel(iChannel);
         }
         // Get the current channel modes
         if (!sParam.equals("324")) { nCurrent = iChannel.getMode(); }
-        
+
         setterCCI = iChannel.getChannelClient(token[0]);
         if (IRCParser.ALWAYS_UPDATECLIENT && setterCCI != null) {
             // Facilitate dmdirc formatter
-            if (setterCCI.getClient().getHostname().isEmpty()) {setterCCI.getClient().setUserBits(token[0],false); }
+            if (setterCCI.getClient().getHostname().isEmpty()) {setterCCI.getClient().setUserBits(token[0], false); }
         }
-        
+
         // Loop through the mode string, and add/remove modes/params where they are needed
         for (int i = 0; i < sModestr[0].length(); ++i) {
             Character cMode = sModestr[0].charAt(i);
             if (cMode.equals(":".charAt(0))) { continue; }
-            
+
             sNonUserModeStr = sNonUserModeStr+cMode;
             if (cMode.equals("+".charAt(0))) { cPositive = '+'; bPositive = true; }
             else if (cMode.equals("-".charAt(0))) { cPositive = '-'; bPositive = false; }
                     }
                     sModeParam = sModestr[nParam++];
                     nValue = myParser.prefixModes.get(cMode);
-                    callDebugInfo(IRCParser.DEBUG_INFO, "User Mode: %c / %d [%s] {Positive: %b}",cMode, nValue, sModeParam, bPositive);
+                    callDebugInfo(IRCParser.DEBUG_INFO, "User Mode: %c / %d [%s] {Positive: %b}", cMode, nValue, sModeParam, bPositive);
                     iChannelClientInfo = iChannel.getChannelClient(sModeParam);
                     if (iChannelClientInfo == null) {
                         // Client not known?
                         iClient = getClientInfo(sModeParam);
-                        if (iClient == null) { 
+                        if (iClient == null) {
                             iClient = new IRCClientInfo(myParser, sModeParam);
                             myParser.addClient(iClient);
                         }
                         iChannelClientInfo = iChannel.addClient(iClient);
                     }
-                    callDebugInfo(IRCParser.DEBUG_INFO, "\tOld Mode Value: %d",iChannelClientInfo.getChanMode());
+                    callDebugInfo(IRCParser.DEBUG_INFO, "\tOld Mode Value: %d", iChannelClientInfo.getChanMode());
                     if (bPositive) { iChannelClientInfo.setChanMode(iChannelClientInfo.getChanMode() | nValue); sTemp = "+"; }
                     else { iChannelClientInfo.setChanMode(iChannelClientInfo.getChanMode() ^ (iChannelClientInfo.getChanMode() & nValue)); sTemp = "-"; }
                     sTemp = sTemp+cMode;
                     continue;
                 } else {
                     // unknown mode - add as boolean
-                    myParser.chanModesBool.put(cMode,myParser.nextKeyCMBool);
+                    myParser.chanModesBool.put(cMode, myParser.nextKeyCMBool);
                     nValue = myParser.nextKeyCMBool;
                     bBooleanMode = true;
                     myParser.nextKeyCMBool = myParser.nextKeyCMBool*2;
                 }
-                
+
                 if (bBooleanMode) {
-                    callDebugInfo(IRCParser.DEBUG_INFO, "Boolean Mode: %c [%d] {Positive: %b}",cMode, nValue, bPositive);
-                    
+                    callDebugInfo(IRCParser.DEBUG_INFO, "Boolean Mode: %c [%d] {Positive: %b}", cMode, nValue, bPositive);
+
                     if (bPositive) { nCurrent = nCurrent | nValue; }
                     else { nCurrent = nCurrent ^ (nCurrent & nValue); }
                 } else {
-                    
+
                     if ((bPositive || nValue == IRCParser.MODE_LIST || ((nValue & IRCParser.MODE_UNSET) == IRCParser.MODE_UNSET)) && (sModestr.length <= nParam)) {
                         myParser.callErrorInfo(new ParserError(ParserError.ERROR_FATAL + ParserError.ERROR_USER, "Broken Modes. Parameter required but not given.", myParser.getLastLine()));
                         continue;
                     }
-                    
+
                     if (nValue == IRCParser.MODE_LIST) {
                         // List Mode
                         sModeParam = sModestr[nParam++];
                         sNonUserModeStrParams = sNonUserModeStrParams+" "+sModeParam;
                         nTemp = (Calendar.getInstance().getTimeInMillis() / 1000);
                         iChannel.setListModeParam(cMode, new ChannelListModeItem(sModeParam, token[0], nTemp), bPositive);
-                        callDebugInfo(IRCParser.DEBUG_INFO, "List Mode: %c [%s] {Positive: %b}",cMode, sModeParam, bPositive);
+                        callDebugInfo(IRCParser.DEBUG_INFO, "List Mode: %c [%s] {Positive: %b}", cMode, sModeParam, bPositive);
                         if (cbSingle != null) { cbSingle.call(iChannel, setterCCI, token[0], cPositive+cMode+" "+sModeParam); }
                     } else {
                         // Mode with a parameter
-                        if (bPositive) { 
+                        if (bPositive) {
                             // +Mode - always needs a parameter to set
                             sModeParam = sModestr[nParam++];
                             sNonUserModeStrParams = sNonUserModeStrParams+" "+sModeParam;
-                            callDebugInfo(IRCParser.DEBUG_INFO, "Set Mode: %c [%s] {Positive: %b}",cMode, sModeParam, bPositive);
-                            iChannel.setModeParam(cMode,sModeParam);
+                            callDebugInfo(IRCParser.DEBUG_INFO, "Set Mode: %c [%s] {Positive: %b}", cMode, sModeParam, bPositive);
+                            iChannel.setModeParam(cMode, sModeParam);
                             if (cbSingle != null) { cbSingle.call(iChannel, setterCCI, token[0], cPositive+cMode+" "+sModeParam); }
                         } else {
                             // -Mode - parameter isn't always needed, we need to check
                             } else {
                                 sModeParam = "";
                             }
-                            callDebugInfo(IRCParser.DEBUG_INFO, "Unset Mode: %c [%s] {Positive: %b}",cMode, sModeParam, bPositive);
-                            iChannel.setModeParam(cMode,"");
+                            callDebugInfo(IRCParser.DEBUG_INFO, "Unset Mode: %c [%s] {Positive: %b}", cMode, sModeParam, bPositive);
+                            iChannel.setModeParam(cMode, "");
                             if (cbSingle != null) { cbSingle.call(iChannel, setterCCI, token[0], trim(cPositive+cMode+" "+sModeParam)); }
                         }
                     }
                 }
             }
         }
-        
+
         // Call Callbacks
         for (int i = 0; i < sModestr.length; ++i) { sFullModeStr.append(sModestr[i]).append(" "); }
-        
+
         iChannel.setMode(nCurrent);
         if (sParam.equals("324")) { callChannelModeChanged(iChannel, null, "", sFullModeStr.toString().trim()); }
         else { callChannelModeChanged(iChannel, setterCCI, token[0], sFullModeStr.toString().trim()); }
         if (cbNonUser != null) { cbNonUser.call(iChannel, setterCCI, token[0], trim(sNonUserModeStr+sNonUserModeStrParams)); }
     }
-    
+
     /**
      * Process user modes.
      *
      * @param sParam String representation of parameter to parse
      * @param token IRCTokenised Array of the incomming line
      * @param clearOldModes Clear old modes before applying these modes (used by 221)
-     */    
+     */
     private void processUserMode(String sParam, String[] token, String[] sModestr, boolean clearOldModes) {
         long nCurrent = 0, nValue = 0;
         boolean bPositive = true;
-        
+
         IRCClientInfo iClient = getClientInfo(token[2]);
-                
+
         if (iClient == null) { return; }
-        
+
         if (clearOldModes) {
             nCurrent = 0;
         } else {
             nCurrent = iClient.getUserMode();
         }
-        
+
         for (int i = 0; i < sModestr[0].length(); ++i) {
             Character cMode = sModestr[0].charAt(i);
             if (cMode.equals("+".charAt(0))) { bPositive = true; }
                 else {
                     // Unknown mode
                     callErrorInfo(new ParserError(ParserError.ERROR_WARNING, "Got unknown user mode "+cMode+" - Added", myParser.getLastLine()));
-                    myParser.userModes.put(cMode,myParser.nNextKeyUser);
+                    myParser.userModes.put(cMode, myParser.nNextKeyUser);
                     nValue = myParser.nNextKeyUser;
                     myParser.nNextKeyUser = myParser.nNextKeyUser*2;
                 }
                 // Usermodes are always boolean
-                callDebugInfo(IRCParser.DEBUG_INFO, "User Mode: %c [%d] {Positive: %b}",cMode, nValue, bPositive);
+                callDebugInfo(IRCParser.DEBUG_INFO, "User Mode: %c [%d] {Positive: %b}", cMode, nValue, bPositive);
                 if (bPositive) { nCurrent = nCurrent | nValue; }
                 else { nCurrent = nCurrent ^ (nCurrent & nValue); }
             }
         }
-        
+
         iClient.setUserMode(nCurrent);
         if (sParam.equals("221")) {
             callUserModeDiscovered(iClient, sModestr[0]);
             callUserModeChanged(iClient, token[0], sModestr[0]);
         }
     }
-    
+
     /**
      * Callback to all objects implementing the ChannelModeChanged Callback.
      *
     protected boolean callChannelModeChanged(ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sHost, String sModes) {
         return getCallbackManager().getCallbackType(ChannelModeChangeListener.class).call(cChannel, cChannelClient, sHost, sModes);
     }
-    
+
     /**
      * Callback to all objects implementing the ChannelUserModeChanged Callback.
      *
     protected boolean callChannelUserModeChanged(ChannelInfo cChannel, ChannelClientInfo cChangedClient, ChannelClientInfo cSetByClient, String sHost, String sMode) {
         return getCallbackManager().getCallbackType(ChannelUserModeChangeListener.class).call(cChannel, cChangedClient, cSetByClient, sHost, sMode);
     }
-    
+
     /**
      * Callback to all objects implementing the UserModeChanged Callback.
      *
     protected boolean callUserModeChanged(ClientInfo cClient, String sSetby, String sModes) {
         return getCallbackManager().getCallbackType(UserModeChangeListener.class).call(cClient, sSetby, sModes);
     }
-    
+
     /**
      * Callback to all objects implementing the UserModeDiscovered Callback.
      *
      */
     protected boolean callUserModeDiscovered(ClientInfo cClient, String sModes) {
         return getCallbackManager().getCallbackType(UserModeDiscoveryListener.class).call(cClient, sModes);
-    }    
-    
+    }
+
     /**
      * What does this IRCProcessor handle.
      *
     @Override
     public String[] handles() {
         return new String[]{"MODE", "324", "221"};
-    } 
-    
+    }
+
     /**
      * Create a new instance of the IRCProcessor Object.
      *

src/com/dmdirc/parser/irc/ProcessNames.java

                         break;
                     }
                 }
-                callDebugInfo(IRCParser.DEBUG_INFO, "Name: %s Modes: \"%s\" [%d]",sName,sModes.toString(),nPrefix);
+                callDebugInfo(IRCParser.DEBUG_INFO, "Name: %s Modes: \"%s\" [%d]", sName, sModes.toString(), nPrefix);
                 
                 iClient = getClientInfo(sName);
                 if (iClient == null) { iClient = new IRCClientInfo(myParser, sName); myParser.addClient(iClient); }
      * @return true if a method was called, false otherwise
      */
     protected boolean callChannelTopic(final ChannelInfo cChannel, final boolean bIsJoinTopic) {
-        ((IRCChannelInfo)cChannel).setHadTopic();
+        ((IRCChannelInfo) cChannel).setHadTopic();
         return getCallbackManager().getCallbackType(ChannelTopicListener.class).call(cChannel, bIsJoinTopic);
     }
 

src/com/dmdirc/parser/irc/ProcessNick.java

                 myParser.forceRemoveClient(getClientInfo(oldNickname));
             }
             // Change the nickame
-            iClient.setUserBits(token[token.length-1],true);
+            iClient.setUserBits(token[token.length-1], true);
             // Readd the client
             if (!isSameNick && getClientInfo(iClient.getNickname()) != null) {
 //                myParser.onPostErrorInfo(new ParserError(ParserError.ERROR_FATAL, "Nick change would overwrite existing client", myParser.getLastLine()), false);
                         if (!isSameNick) {
                             iChannel.renameClient(oldNickname, iChannelClient);
                         }
-                        callChannelNickChanged(iChannel,iChannelClient,IRCClientInfo.parseHost(token[0]));
+                        callChannelNickChanged(iChannel, iChannelClient, IRCClientInfo.parseHost(token[0]));
                     }
                 }
                 

src/com/dmdirc/parser/irc/ProcessNickInUse.java

     public void process(final String sParam, final String[] token) {
         if (!callNickInUse(token[3])) {
             // Manually handle nick in use.
-            callDebugInfo(IRCParser.DEBUG_INFO,"No Nick in use Handler.");
+            callDebugInfo(IRCParser.DEBUG_INFO, "No Nick in use Handler.");
             if (!myParser.got001) {
-                callDebugInfo(IRCParser.DEBUG_INFO,"Using inbuilt handler");
+                callDebugInfo(IRCParser.DEBUG_INFO, "Using inbuilt handler");
                 // If this is before 001 we will try and get a nickname, else we will leave the nick as-is
                 if (myParser.triedAlt) {
                     if (myParser.getStringConverter().equalsIgnoreCase(myParser.thinkNickname, myParser.me.getAltNickname())) {

src/com/dmdirc/parser/irc/ProcessPart.java

         if (iClient == null) { return; }
         if (IRCParser.ALWAYS_UPDATECLIENT && iClient.getHostname().isEmpty()) {
             // This may seem pointless - updating before they leave - but the formatter needs it!
-            iClient.setUserBits(token[0],false);
+            iClient.setUserBits(token[0], false);
         }
         if (iChannel == null) { 
             if (iClient != myParser.getLocalClient()) {
                 // callErrorInfo(new ParserError(ParserError.ERROR_WARNING, "Got part for channel ("+token[2]+") for a non-existant user. [User: "+token[0]+"]", myParser.getLastLine()));
                 return;
             }
-            if (myParser.removeAfterCallback) { callChannelPart(iChannel,iChannelClient,sReason); }
-            callDebugInfo(IRCParser.DEBUG_INFO, "Removing %s from %s",iClient.getNickname(),iChannel.getName());
+            if (myParser.removeAfterCallback) { callChannelPart(iChannel, iChannelClient, sReason); }
+            callDebugInfo(IRCParser.DEBUG_INFO, "Removing %s from %s", iClient.getNickname(), iChannel.getName());
             iChannel.delClient(iClient);
-            if (!myParser.removeAfterCallback) { callChannelPart(iChannel,iChannelClient,sReason); }
+            if (!myParser.removeAfterCallback) { callChannelPart(iChannel, iChannelClient, sReason); }
             if (iClient == myParser.getLocalClient()) {
                 iChannel.emptyChannel();
                 myParser.removeChannel(iChannel);

src/com/dmdirc/parser/irc/ProcessQuit.java

         if (iClient == null) { return; }
         if (IRCParser.ALWAYS_UPDATECLIENT && iClient.getHostname().isEmpty()) {
             // This may seem pointless - updating before they leave - but the formatter needs it!
-            iClient.setUserBits(token[0],false);
+            iClient.setUserBits(token[0], false);
         }
         String sReason = "";
         if (token.length > 2) { sReason = token[token.length-1]; }
         for (IRCChannelInfo iChannel : channelList) {
             iChannelClient = iChannel.getChannelClient(iClient);
             if (iChannelClient != null) {
-                if (myParser.removeAfterCallback) { callChannelQuit(iChannel,iChannelClient,sReason); }
+                if (myParser.removeAfterCallback) { callChannelQuit(iChannel, iChannelClient, sReason); }
                 if (iClient == myParser.getLocalClient()) {
                     iChannel.emptyChannel();
                     myParser.removeChannel(iChannel);
                 } else {
                     iChannel.delClient(iClient);
                 }
-                if (!myParser.removeAfterCallback) { callChannelQuit(iChannel,iChannelClient,sReason); }
+                if (!myParser.removeAfterCallback) { callChannelQuit(iChannel, iChannelClient, sReason); }
             }
         }
 
-        if (myParser.removeAfterCallback) { callQuit(iClient,sReason); }
+        if (myParser.removeAfterCallback) { callQuit(iClient, sReason); }
         if (iClient == myParser.getLocalClient()) {
             myParser.clearClients();
         } else {
             myParser.removeClient(iClient);
         }
-        if (!myParser.removeAfterCallback) { callQuit(iClient,sReason); }
+        if (!myParser.removeAfterCallback) { callQuit(iClient, sReason); }
     }    
     
     /**

src/com/dmdirc/parser/irc/ProcessTopic.java

                         iChannel.setTopicTime(Long.parseLong(token[5]));
                     }
                 }
-                callChannelTopic(iChannel,true);
+                callChannelTopic(iChannel, true);
             }
         } else {
             if (IRCParser.ALWAYS_UPDATECLIENT) {
                 final IRCClientInfo iClient = getClientInfo(token[0]);
-                if (iClient != null && iClient.getHostname().isEmpty()) {iClient.setUserBits(token[0],false); }
+                if (iClient != null && iClient.getHostname().isEmpty()) {iClient.setUserBits(token[0], false); }
             }
             iChannel = getChannel(token[2]);
             if (iChannel == null) { return; }
             if (token[0].charAt(0) == ':') { token[0] = token[0].substring(1); }
             iChannel.setTopicUser(token[0]);
             iChannel.setInternalTopic(token[token.length-1]);
-            callChannelTopic(iChannel,false);
+            callChannelTopic(iChannel, false);
         }
     }
     
      * @return true if a method was called, false otherwise
      */
     protected boolean callChannelTopic(final ChannelInfo cChannel, final boolean bIsJoinTopic) {
-        ((IRCChannelInfo)cChannel).setHadTopic();
+        ((IRCChannelInfo) cChannel).setHadTopic();
         return getCallbackManager().getCallbackType(ChannelTopicListener.class).call(cChannel, bIsJoinTopic);
     }
     

src/com/dmdirc/parser/irc/ProcessWho.java

                     for (ChannelInfo iChannel : myParser.getChannels()) {
                         iChannelClient = iChannel.getChannelClient(client);
                         if (iChannelClient != null) {
-                            callChannelAwayStateOther(iChannel,iChannelClient,oldState,isAway);
+                            callChannelAwayStateOther(iChannel, iChannelClient, oldState, isAway);
                         }
                     }
                 }

src/com/dmdirc/parser/irc/ProcessingManager.java

     IRCParser myParser;
 
     /** Hashtable used to store the different types of IRCProcessor known. */
-    private final Hashtable<String,IRCProcessor> processHash = new Hashtable<String,IRCProcessor>();
+    private final Hashtable<String, IRCProcessor> processHash = new Hashtable<String, IRCProcessor>();
 
     /**
      * Debugging Data to the console.

test/com/dmdirc/parser/irc/ChannelInfoTest.java

         assertEquals("NOTICE #DMDirc_testing :" + ((char) 1) + "TYPE" + ((char) 1),
                 parser.sentLines.get(0));
     }
-    
+
     @Test
     public void testSendEmptyMessages() {
         final TestParser parser = new TestParser();
         final IRCChannelInfo info = getChannel(parser);
-        
+
         info.sendAction("");
         info.sendCTCP("", "");
         info.sendCTCPReply("", "");
 
         assertEquals(0, parser.sentLines.size());
     }
-    
+
     @Test
     public void testGetSetParamMode() {
         final TestParser parser = new TestParser();
         final ChannelInfo info = getChannel(parser);
         parser.injectLine(":server 324 nick #DMDirc_testing +k lalala");
         parser.sentLines.clear();
-        
+
         assertEquals("lalala", info.getMode('k'));
         assertEquals("", info.getMode('z'));
-        
+
         parser.injectLine(":server MODE #DMDirc_testing -k *");
-        
+
         assertEquals("", info.getMode('k'));
     }
-    
+
     @Test
     public void testModeSendFull() {
         final TestParser parser = new TestParser();
         info.alterMode(true, 'p', null);
         info.alterMode(true, 't', null);
         info.alterMode(true, 'r', null);
-        
+
         assertEquals("Parser must send modes as soon as the max number is reached",
                 1, parser.sentLines.size());
         final String modes = getModes(parser.sentLines.get(0));
-        
+
         assertTrue(modes.indexOf('i') > -1);
         assertTrue(modes.indexOf('m') > -1);
         assertTrue(modes.indexOf('n') > -1);
         assertTrue(modes.indexOf('t') > -1);
         assertTrue(modes.indexOf('r') > -1);
     }
-    
+
     @Test
     public void testModeSendExtra() {
         final TestParser parser = new TestParser();
         info.alterMode(true, 'r', null);
         info.alterMode(true, 'N', null);
         info.flushModes();
-        
+
         assertEquals("sendModes must send modes",
                 2, parser.sentLines.size());
-        
+
         final String modes = getModes(parser.sentLines.get(0))
                 + getModes(parser.sentLines.get(1));
-        
+
         assertTrue(modes.indexOf('i') > -1);
         assertTrue(modes.indexOf('m') > -1);
         assertTrue(modes.indexOf('n') > -1);
         assertTrue(modes.indexOf('r') > -1);
         assertTrue(modes.indexOf('N') > -1);
     }
-    
+
     @Test
     public void testModeSendOptimisation1() {
         final TestParser parser = new TestParser();
         info.alterMode(true, 'n', null);
         info.alterMode(false, 'i', null);
         info.flushModes();
-        
+
         assertEquals("sendModes must send modes in one go",
                 1, parser.sentLines.size());
-        
+
         final String modes = getModes(parser.sentLines.get(0));
-        
+
         assertEquals("Setting a negative mode should cancel a positive one",
                 -1, modes.indexOf('i'));
-        
+
         assertTrue(modes.indexOf('m') > -1);
     }
-    
+
     @Test
     public void testModeSendOptimisation2() {
         final TestParser parser = new TestParser();
         info.alterMode(true, 'n', null);
         info.alterMode(true, 'n', null);
         info.flushModes();
-        
+
         assertEquals("sendModes must send modes in one go",
                 1, parser.sentLines.size());
-        
+
         final String modes = getModes(parser.sentLines.get(0));
-        
+
         assertEquals("Setting a mode twice should have no effect",
                 modes.indexOf('n'), modes.lastIndexOf('n'));
-        
+
         assertTrue(modes.indexOf('m') > -1);
     }
-    
+
     @Test
     public void testModeUnsetKey() {
         final TestParser parser = new TestParser();
         final ChannelInfo info = getChannel(parser);
         parser.injectLine(":server 324 nick #DMDirc_testing +k lalala");
         parser.sentLines.clear();
-        
+
         info.alterMode(true, 'k', "foobar");
         info.flushModes();
-        
+
         assertEquals("sendModes must send modes in one go",
                 1, parser.sentLines.size());
         assertEquals("Setting +k must set -k first",
                 "-k+k lalala foobar", getModes(parser.sentLines.get(0)));
     }
-    
+
     @Test
     public void testIssue1410() {
         final TestParser parser = new TestParser();
         assertEquals(parser.getChannel("#DMDirc_testing").getChannelClients(),
                 parser.getChannel("#DMDirc_testing").getChannelClients());
     }
-    
+
     @Test @Ignore
     public void testModeUnsetKeyMultiple() {
         final TestParser parser = new TestParser();
         final ChannelInfo info = getChannel(parser);
         parser.injectLine(":server 324 nick #DMDirc_testing +k lalala");
         parser.sentLines.clear();
-        
+
         info.alterMode(true, 'k', "foobar");
         info.alterMode(true, 'k', "blahblah");
         info.alterMode(true, 'k', "unittest");
         info.flushModes();
-        
+
         assertEquals("sendModes must send modes in one go",
                 1, parser.sentLines.size());
         assertEquals("Setting a mode multiple times should have no effect",
                 "-k+k lalala unittest", getModes(parser.sentLines.get(0)));
     }
-    
+
     @Test @Ignore
     public void testModeUnsetLimitMultiple() {
         final TestParser parser = new TestParser();
         final ChannelInfo info = getChannel(parser);
         parser.injectLine(":server 324 nick #DMDirc_testing +l 73");
         parser.sentLines.clear();
-        
+
         info.alterMode(true, 'l', "74");
         info.alterMode(true, 'l', "75");
         info.alterMode(true, 'l', "76");
         info.flushModes();
-        
+
         assertEquals("sendModes must send modes in one go",
                 1, parser.sentLines.size());
         assertEquals("Setting a mode multiple times should have no effect",
                 "+l 76", getModes(parser.sentLines.get(0)));
     }
-    
+
     private String getModes(final String line) {
         final String res = line.substring("MODE #DMDirc_testing ".length());
-        
+
         if (res.charAt(0) == '+') {
             return res.substring(1);
         }
-        
+
         return res;
     }