Abstract CommandInfos somewhat

src/com/dmdirc/Channel.java

 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.config.ConfigManager;
 import com.dmdirc.interfaces.ConfigChangeListener;
+import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.ClientInfo;
 import com.dmdirc.ui.WindowManager;
 import com.dmdirc.ui.input.TabCompleter;
      * @param newChannelInfo The parser's channel object that corresponds to
      * this channel
      */
-    public Channel(final Server newServer, final ChannelInfo newChannelInfo) {
+    public Channel(final Server newServer, final IRCChannelInfo newChannelInfo) {
         super("channel", newChannelInfo.getName(),
                 new ConfigManager(newServer.getIrcd(), newServer.getNetwork(),
                 newServer.getName(), newChannelInfo.getName()));
     @Override
     public void sendLine(final String line) {
         if (server.getState() != ServerState.CONNECTED
-                || server.getParser().getChannelInfo(channelInfo.getName()) == null) {
+                || server.getParser().getChannel(channelInfo.getName()) == null) {
             // We're not in the channel/connected to the server
             return;
         }
     @Override
     public void sendAction(final String action) {
         if (server.getState() != ServerState.CONNECTED
-                || server.getParser().getChannelInfo(channelInfo.getName()) == null) {
+                || server.getParser().getChannel(channelInfo.getName()) == null) {
             // We're not on the server/channel
             return;
         }
      *
      * @param newChannelInfo The new ChannelInfo object
      */
-    public void setChannelInfo(final ChannelInfo newChannelInfo) {
+    public void setChannelInfo(final IRCChannelInfo newChannelInfo) {
         channelInfo = newChannelInfo;
         registerCallbacks();
     }

src/com/dmdirc/ChannelEventHandler.java

 import com.dmdirc.actions.CoreActionType;
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.ClientInfo;
 import com.dmdirc.parser.irc.callbacks.CallbackManager;
 import com.dmdirc.parser.irc.callbacks.CallbackNotFoundException;
     /** {@inheritDoc} */
     @Override
     public void onChannelMessage(final Parser tParser,
-            final ChannelInfo cChannel, final ChannelClientInfo cChannelClient,
+            final IRCChannelInfo cChannel, final ChannelClientInfo cChannelClient,
             final String sMessage, final String sHost) {
         checkParser(tParser);
 
 
     /** {@inheritDoc} */
     @Override
-    public void onChannelGotNames(final Parser tParser, final ChannelInfo cChannel) {
+    public void onChannelGotNames(final Parser tParser, final IRCChannelInfo cChannel) {
         checkParser(tParser);
 
         owner.setClients(cChannel.getChannelClients());
     /** {@inheritDoc} */
     @Override
     public void onChannelTopic(final Parser tParser,
-            final ChannelInfo cChannel, final boolean bIsJoinTopic) {
+            final IRCChannelInfo cChannel, final boolean bIsJoinTopic) {
         checkParser(tParser);
 
         final Topic newTopic = new Topic(cChannel.getTopic(),
 
     /** {@inheritDoc} */
     @Override
-    public void onChannelJoin(final Parser tParser, final ChannelInfo cChannel,
+    public void onChannelJoin(final Parser tParser, final IRCChannelInfo cChannel,
             final ChannelClientInfo cChannelClient) {
         checkParser(tParser);
 
 
     /** {@inheritDoc} */
     @Override
-    public void onChannelPart(final Parser tParser, final ChannelInfo cChannel,
+    public void onChannelPart(final Parser tParser, final IRCChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sReason) {
         checkParser(tParser);
 
 
     /** {@inheritDoc} */
     @Override
-    public void onChannelKick(final Parser tParser, final ChannelInfo cChannel,
+    public void onChannelKick(final Parser tParser, final IRCChannelInfo cChannel,
             final ChannelClientInfo cKickedClient, final ChannelClientInfo cKickedByClient,
             final String sReason, final String sKickedByHost) {
         checkParser(tParser);
 
     /** {@inheritDoc} */
     @Override
-    public void onChannelQuit(final Parser tParser, final ChannelInfo cChannel,
+    public void onChannelQuit(final Parser tParser, final IRCChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sReason) {
         checkParser(tParser);
 
 
     /** {@inheritDoc} */
     @Override
-    public void onChannelAction(final Parser tParser, final ChannelInfo cChannel,
+    public void onChannelAction(final Parser tParser, final IRCChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sMessage,
             final String sHost) {
         checkParser(tParser);
 
     /** {@inheritDoc} */
     @Override
-    public void onChannelNickChanged(final Parser tParser, final ChannelInfo cChannel,
+    public void onChannelNickChanged(final Parser tParser, final IRCChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sOldNick) {
         checkParser(tParser);
 
 
     /** {@inheritDoc} */
     @Override
-    public void onChannelModeChanged(final Parser tParser, final ChannelInfo cChannel,
+    public void onChannelModeChanged(final Parser tParser, final IRCChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sHost,
             final String sModes) {
         checkParser(tParser);
     /** {@inheritDoc} */
     @Override
     public void onChannelUserModeChanged(final Parser tParser,
-            final ChannelInfo cChannel, final ChannelClientInfo cChangedClient,
+            final IRCChannelInfo cChannel, final ChannelClientInfo cChangedClient,
             final ChannelClientInfo cSetByClient, final String sHost, final String sMode) {
         checkParser(tParser);
 
 
     /** {@inheritDoc} */
     @Override
-    public void onChannelCTCP(final Parser tParser, final ChannelInfo cChannel,
+    public void onChannelCTCP(final Parser tParser, final IRCChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sType,
             final String sMessage, final String sHost) {
         checkParser(tParser);
     /** {@inheritDoc} */
     @Override
     public void onChannelNotice(final Parser tParser,
-            final ChannelInfo cChannel, final ChannelClientInfo cChannelClient,
+            final IRCChannelInfo cChannel, final ChannelClientInfo cChannelClient,
             final String sMessage, final String sHost) {
         checkParser(tParser);
 

src/com/dmdirc/Server.java

 import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.logger.Logger;
 import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.ClientInfo;
 import com.dmdirc.parser.irc.IRCStringConverter;
 import com.dmdirc.parser.irc.MyInfo;
      *
      * @param chan channel to add
      */
-    public void addChannel(final ChannelInfo chan) {
+    public void addChannel(final IRCChannelInfo chan) {
         synchronized (myState) {
             if (myState.getState() == ServerState.CLOSING) {
                 // Can't join channels while the server is closing

src/com/dmdirc/ServerEventHandler.java

 import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.logger.Logger;
 import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.ClientInfo;
 import com.dmdirc.parser.irc.ParserError;
 import com.dmdirc.parser.irc.callbacks.CallbackManager;
 
     /** {@inheritDoc} */
     @Override
-    public void onChannelSelfJoin(final Parser tParser, final ChannelInfo cChannel) {
+    public void onChannelSelfJoin(final Parser tParser, final IRCChannelInfo cChannel) {
         checkParser(tParser);
         owner.addChannel(cChannel);
     }

src/com/dmdirc/addons/logging/LoggingPlugin.java

 import com.dmdirc.logger.Logger;
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.ClientInfo;
 import com.dmdirc.plugins.Plugin;
 import com.dmdirc.ui.interfaces.InputWindow;
 	 */
 	protected void handleChannelEvent(final CoreActionType type, final StringBuffer format, final Object... arguments) {
 		final Channel chan = ((Channel)arguments[0]);
-		final ChannelInfo channel = chan.getChannelInfo();
+		final IRCChannelInfo channel = chan.getChannelInfo();
 		final String filename = getLogFile(channel);
 		
 		final ChannelClientInfo channelClient = (arguments.length > 1 && arguments[1] instanceof ChannelClientInfo) ? (ChannelClientInfo)arguments[1] : null;
 		
 		if (obj == null) {
 			file.append("null.log");
-		} else if (obj instanceof ChannelInfo) {
-			final ChannelInfo channel = (ChannelInfo) obj;
+		} else if (obj instanceof IRCChannelInfo) {
+			final IRCChannelInfo channel = (IRCChannelInfo) obj;
 			if (channel.getParser() != null) {
 				addNetworkDir(directory, file, channel.getParser().getNetworkName());
 			}

src/com/dmdirc/addons/nickcolours/NickColourPlugin.java

 import com.dmdirc.config.prefs.PreferencesType;
 import com.dmdirc.interfaces.ActionListener;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.ClientInfo;
 import com.dmdirc.plugins.Plugin;
 import com.dmdirc.ui.messages.ColourManager;
     public void processEvent(final ActionType type, final StringBuffer format,
             final Object... arguments) {
         if (type.equals(CoreActionType.CHANNEL_GOTNAMES)) {
-            final ChannelInfo chanInfo = ((Channel) arguments[0]).getChannelInfo();
+            final IRCChannelInfo chanInfo = ((Channel) arguments[0]).getChannelInfo();
             final String network = ((Channel) arguments[0]).getServer().getNetwork();
             
             for (ChannelClientInfo client : chanInfo.getChannelClients()) {

src/com/dmdirc/addons/windowstatus/WindowStatusPlugin.java

 import com.dmdirc.interfaces.ActionListener;
 import com.dmdirc.interfaces.ConfigChangeListener;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.ClientInfo;
 import com.dmdirc.plugins.Plugin;
 import com.dmdirc.ui.interfaces.InputWindow;
 			textString.append(frame.getName());
 		} else if (current instanceof Channel) {
 			final Channel frame = (Channel) current;
-			final ChannelInfo chan = frame.getChannelInfo();
+			final IRCChannelInfo chan = frame.getChannelInfo();
 			final Map<Long, String> names = new Hashtable<Long, String>();
 			final Map<Long, Integer> types = new Hashtable<Long, Integer>();
 

src/com/dmdirc/commandparser/commands/channel/Mode.java

 import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.commands.ExternalCommand;
 import com.dmdirc.commandparser.commands.IntelligentCommand;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.ui.input.AdditionalTabTargets;
 import com.dmdirc.ui.input.TabCompletionType;
 import com.dmdirc.ui.interfaces.InputWindow;
     @Override
     public void execute(final InputWindow origin, final Server server,
             final Channel channel, final boolean isSilent, final CommandArguments args) {
-        final ChannelInfo cChannel = channel.getChannelInfo();
+        final IRCChannelInfo cChannel = channel.getChannelInfo();
 
         if (args.getArguments().length == 0) {
             sendLine(origin, isSilent, "channelModeDiscovered", cChannel.getModeStr(), cChannel);

src/com/dmdirc/commandparser/commands/channel/ShowTopic.java

 import com.dmdirc.commandparser.commands.ChannelCommand;
 import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.commands.ExternalCommand;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.ClientInfo;
 import com.dmdirc.ui.interfaces.InputWindow;
 
     public void execute(final InputWindow origin, final Server server,
             final Channel channel, final boolean isSilent, final CommandArguments args) {
         if (args.getArguments().length == 0) {
-            final ChannelInfo cChannel = channel.getChannelInfo();
+            final IRCChannelInfo cChannel = channel.getChannelInfo();
 
             if (cChannel.getTopic().isEmpty()) {
                 sendLine(origin, isSilent, "channelNoTopic", cChannel);

src/com/dmdirc/parser/interfaces/ChannelInfo.java

+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.interfaces;
+
+/**
+ * Holds information about a channel and allows various operations to be
+ * performed on the channel.
+ *
+ * @since 0.6.3m2
+ * @author chris
+ */
+public interface ChannelInfo {
+
+}

src/com/dmdirc/parser/interfaces/Parser.java

  * A parser connects to a back-end chat system and handles all communication
  * with it.
  *
+ * @since 0.6.3m2
  * @author chris
  */
 public interface Parser extends Runnable {
      */
     void joinChannel(String channel);
 
+    /**
+     * Retrieves a channel information object for the specified channel.
+     *
+     * @param channel Name of the channel to retrieve an information object for
+     * @return A corresponding channel info object
+     */
+    ChannelInfo getChannel(String channel);
+
     /**
      * Set the current Value of bindIP.
      *

src/com/dmdirc/parser/interfaces/callbacks/ChannelActionListener.java

 
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.FakableArgument;
 import com.dmdirc.parser.irc.callbacks.FakableSource;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 	 */
 	void onChannelAction(
             @FakableSource Parser tParser,
-            @FakableSource ChannelInfo cChannel,
+            @FakableSource IRCChannelInfo cChannel,
             @FakableArgument ChannelClientInfo cChannelClient,
             String sMessage,
             @FakableSource String sHost);

src/com/dmdirc/parser/interfaces/callbacks/ChannelCtcpListener.java

 
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.FakableArgument;
 import com.dmdirc.parser.irc.callbacks.FakableSource;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 	 * @see com.dmdirc.parser.irc.ProcessMessage#callChannelCTCP
 	 */
 	void onChannelCTCP(@FakableSource Parser tParser,
-            @FakableSource ChannelInfo cChannel,
+            @FakableSource IRCChannelInfo cChannel,
             @FakableArgument ChannelClientInfo cChannelClient,
             String sType, String sMessage,
             @FakableSource String sHost);

src/com/dmdirc/parser/interfaces/callbacks/ChannelCtcpReplyListener.java

 
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.FakableArgument;
 import com.dmdirc.parser.irc.callbacks.FakableSource;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 	 * @see com.dmdirc.parser.irc.ProcessMessage#callChannelCTCPReply
 	 */
 	void onChannelCTCPReply(@FakableSource Parser tParser,
-            @FakableSource ChannelInfo cChannel,
+            @FakableSource IRCChannelInfo cChannel,
             @FakableArgument ChannelClientInfo cChannelClient,
             String sType, String sMessage,
             @FakableSource String sHost);

src/com/dmdirc/parser/interfaces/callbacks/ChannelJoinListener.java

 
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 
 /** 
 	 * @param cChannelClient ChannelClient object for new person
 	 * @see com.dmdirc.parser.irc.ProcessJoin#callChannelJoin
 	 */
-	void onChannelJoin(Parser tParser, ChannelInfo cChannel, ChannelClientInfo cChannelClient);
+	void onChannelJoin(Parser tParser, IRCChannelInfo cChannel, ChannelClientInfo cChannelClient);
 }

src/com/dmdirc/parser/interfaces/callbacks/ChannelKickListener.java

 
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.FakableArgument;
 import com.dmdirc.parser.irc.callbacks.FakableSource;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 	 * @see com.dmdirc.parser.irc.ProcessKick#callChannelKick
 	 */
 	void onChannelKick(@FakableSource Parser tParser,
-            @FakableSource ChannelInfo cChannel,
+            @FakableSource IRCChannelInfo cChannel,
             ChannelClientInfo cKickedClient,
             @FakableArgument ChannelClientInfo cKickedByClient,
             String sReason,

src/com/dmdirc/parser/interfaces/callbacks/ChannelListModeListener.java

 package com.dmdirc.parser.interfaces.callbacks;
 
 import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 
 /**
 	 * @param cChannel Channel which the ListModes reply is for
 	 * @see com.dmdirc.parser.irc.ProcessListModes#callChannelGotListModes
 	 */
-	void onChannelGotListModes(Parser tParser, ChannelInfo cChannel);
+	void onChannelGotListModes(Parser tParser, IRCChannelInfo cChannel);
 }

src/com/dmdirc/parser/interfaces/callbacks/ChannelMessageListener.java

 
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.FakableArgument;
 import com.dmdirc.parser.irc.callbacks.FakableSource;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 	 * @see com.dmdirc.parser.irc.ProcessMessage#callChannelMessage
 	 */
 	void onChannelMessage(@FakableSource Parser tParser,
-            @FakableSource ChannelInfo cChannel,
+            @FakableSource IRCChannelInfo cChannel,
             @FakableArgument ChannelClientInfo cChannelClient,
             String sMessage,
             @FakableSource String sHost);

src/com/dmdirc/parser/interfaces/callbacks/ChannelModeChangeListener.java

 
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.FakableArgument;
 import com.dmdirc.parser.irc.callbacks.FakableSource;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 	 * @see com.dmdirc.parser.irc.ProcessMode#callChannelModeChanged
 	 */
 	void onChannelModeChanged(@FakableSource Parser tParser,
-            @FakableSource ChannelInfo cChannel,
+            @FakableSource IRCChannelInfo cChannel,
             @FakableArgument ChannelClientInfo cChannelClient,
             @FakableSource String sHost,
             String sModes);

src/com/dmdirc/parser/interfaces/callbacks/ChannelModeMessageListener.java

 
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.FakableArgument;
 import com.dmdirc.parser.irc.callbacks.FakableSource;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 	 */
 	void onChannelModeMessage(@FakableSource Parser tParser,
             char prefix,
-            @FakableSource ChannelInfo cChannel,
+            @FakableSource IRCChannelInfo cChannel,
             @FakableArgument ChannelClientInfo cChannelClient,
             String sMessage,
             @FakableSource String sHost);

src/com/dmdirc/parser/interfaces/callbacks/ChannelModeNoticeListener.java

 
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.FakableArgument;
 import com.dmdirc.parser.irc.callbacks.FakableSource;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 	 */
 	void onChannelModeNotice(@FakableSource Parser tParser,
             char prefix,
-            @FakableSource ChannelInfo cChannel,
+            @FakableSource IRCChannelInfo cChannel,
             @FakableArgument ChannelClientInfo cChannelClient,
             String sMessage,
             @FakableSource String sHost);

src/com/dmdirc/parser/interfaces/callbacks/ChannelNamesListener.java

 package com.dmdirc.parser.interfaces.callbacks;
 
 import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 
 /**
 	 * @param cChannel Channel which the names reply is for
 	 * @see com.dmdirc.parser.irc.ProcessNames#callChannelGotNames
 	 */
-	void onChannelGotNames(Parser tParser, ChannelInfo cChannel);
+	void onChannelGotNames(Parser tParser, IRCChannelInfo cChannel);
 }

src/com/dmdirc/parser/interfaces/callbacks/ChannelNickChangeListener.java

 
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 
 /** 
 	 * @param sOldNick Nickname before change
 	 * @see com.dmdirc.parser.irc.ProcessNick#callChannelNickChanged
 	 */
-	 void onChannelNickChanged(Parser tParser, ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sOldNick);
+	 void onChannelNickChanged(Parser tParser, IRCChannelInfo cChannel, ChannelClientInfo cChannelClient, String sOldNick);
 }

src/com/dmdirc/parser/interfaces/callbacks/ChannelNonUserModeChangeListener.java

 
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.FakableArgument;
 import com.dmdirc.parser.irc.callbacks.FakableSource;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 	 * @param sModes String showing the exact mode change parsed. (Not including user modes)
 	 */
 	void onChannelNonUserModeChanged(@FakableSource Parser tParser,
-            @FakableSource ChannelInfo cChannel,
+            @FakableSource IRCChannelInfo cChannel,
             @FakableArgument ChannelClientInfo cChannelClient,
             @FakableSource String sHost,
             String sModes);

src/com/dmdirc/parser/interfaces/callbacks/ChannelNoticeListener.java

 
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.FakableArgument;
 import com.dmdirc.parser.irc.callbacks.FakableSource;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 	 * @see com.dmdirc.parser.irc.ProcessMessage#callChannelNotice
 	 */
 	void onChannelNotice(@FakableSource Parser tParser,
-            @FakableSource ChannelInfo cChannel,
+            @FakableSource IRCChannelInfo cChannel,
             @FakableArgument ChannelClientInfo cChannelClient,
             String sMessage,
             @FakableSource String sHost);

src/com/dmdirc/parser/interfaces/callbacks/ChannelOtherAwayStateListener.java

 
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 
 /**
 	 * @param state Away State (true if away, false if here)
 	 * @see com.dmdirc.parser.irc.ProcessAway#callChannelAwayStateOther
 	 */
-	void onChannelAwayStateOther(Parser tParser, ChannelInfo channel, ChannelClientInfo channelClient, boolean state);
+	void onChannelAwayStateOther(Parser tParser, IRCChannelInfo channel, ChannelClientInfo channelClient, boolean state);
 }

src/com/dmdirc/parser/interfaces/callbacks/ChannelPartListener.java

 
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 
 /** 
 	 * @param sReason Reason given for parting (May be "")
 	 * @see com.dmdirc.parser.irc.ProcessPart#callChannelPart
 	 */
-	void onChannelPart(Parser tParser, ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sReason);
+	void onChannelPart(Parser tParser, IRCChannelInfo cChannel, ChannelClientInfo cChannelClient, String sReason);
 }

src/com/dmdirc/parser/interfaces/callbacks/ChannelQuitListener.java

 
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 
 /** 
 	 * @param sReason Quit reason
 	 * @see com.dmdirc.parser.irc.ProcessQuit#callChannelQuit
 	 */
-	void onChannelQuit(Parser tParser, ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sReason);
+	void onChannelQuit(Parser tParser, IRCChannelInfo cChannel, ChannelClientInfo cChannelClient, String sReason);
 }

src/com/dmdirc/parser/interfaces/callbacks/ChannelSelfJoinListener.java

 package com.dmdirc.parser.interfaces.callbacks;
 
 import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 
 /** 
  * Called When we join a channel.
 	 * @param cChannel Channel Object
 	 * @see com.dmdirc.parser.irc.ProcessJoin#callChannelSelfJoin
 	 */
-	void onChannelSelfJoin(Parser tParser, ChannelInfo cChannel);
+	void onChannelSelfJoin(Parser tParser, IRCChannelInfo cChannel);
 }

src/com/dmdirc/parser/interfaces/callbacks/ChannelSingleModeChangeListener.java

 
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.FakableArgument;
 import com.dmdirc.parser.irc.callbacks.FakableSource;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 	 * @param sModes String parsed (ie "+m" or "+k moo"
 	 */
 	void onChannelSingleModeChanged(@FakableSource Parser tParser,
-            @FakableSource ChannelInfo cChannel,
+            @FakableSource IRCChannelInfo cChannel,
             @FakableArgument ChannelClientInfo cChannelClient,
             @FakableSource String sHost,
             String sModes);

src/com/dmdirc/parser/interfaces/callbacks/ChannelTopicListener.java

 package com.dmdirc.parser.interfaces.callbacks;
 
 import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 
 /** 
 	 * @param bIsJoinTopic True when getting topic on join, false if set by user/server
 	 * @see com.dmdirc.parser.irc.ProcessTopic#callChannelTopic
 	 */
-	void onChannelTopic(Parser tParser, ChannelInfo cChannel, boolean bIsJoinTopic);
+	void onChannelTopic(Parser tParser, IRCChannelInfo cChannel, boolean bIsJoinTopic);
 }

src/com/dmdirc/parser/interfaces/callbacks/ChannelUserModeChangeListener.java

 
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.callbacks.FakableArgument;
 import com.dmdirc.parser.irc.callbacks.FakableSource;
 import com.dmdirc.parser.irc.callbacks.SpecificCallback;
 	 * @see com.dmdirc.parser.irc.ProcessMode#callChannelUserModeChanged
 	 */
 	void onChannelUserModeChanged(@FakableSource Parser tParser,
-            @FakableSource ChannelInfo cChannel,
+            @FakableSource IRCChannelInfo cChannel,
             ChannelClientInfo cChangedClient,
             @FakableArgument ChannelClientInfo cSetByClient,
             @FakableSource String sHost,

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

 	/** Reference to the parser object that owns this channelclient, Used for modes. */
 	private final IRCParser myParser;
 	/** Reference to the channel object that owns this channelclient. */
-	private final ChannelInfo myChannel;
+	private final IRCChannelInfo myChannel;
 	/** A Map to allow applications to attach misc data to this object */
 	private Map myMap;
 	
 	 * @param client Client that this channelclient represents
 	 * @param channel Channel that owns this channelclient
 	 */	
-	public ChannelClientInfo(final IRCParser tParser, final ClientInfo client, final ChannelInfo channel) {
+	public ChannelClientInfo(final IRCParser tParser, final ClientInfo client, final IRCChannelInfo channel) {
 		myMap = new HashMap<Object, Object>();
 		myParser = tParser;
 		cClient = client;
 	 *
 	 * @return Channel object that owns this ChannelClient
 	 */
-	public ChannelInfo getChannel() { return myChannel; }
+	public IRCChannelInfo getChannel() { return myChannel; }
 	/**
 	 * Get the nickname of the client object represented by this channelclient.
 	 *

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.ChannelInfo;
 import java.util.ArrayList;
 import java.util.Hashtable;
 import java.util.HashMap;
  * @author Chris Smith
  * @see IRCParser
  */
-public class ChannelInfo {
+public class IRCChannelInfo implements ChannelInfo {
 	/**
 	 * Boolean repreenting the status of names requests.
 	 * When this is false, any new names reply will cause current known channelclients to be removed.
 	 * @param tParser Refernce to parser that owns this channelclient (used for modes)	 
 	 * @param name Channel name.
 	 */
-	public ChannelInfo(final IRCParser tParser, final String name) {
+	public IRCChannelInfo(final IRCParser tParser, final String name) {
 		myMap = new HashMap<Object, Object>();
 		myParser = tParser;
 		sName = name;

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.interfaces.callbacks.ConnectErrorListener;
 import com.dmdirc.parser.interfaces.callbacks.DataInListener;
 	/** Hashtable storing all known clients based on nickname (in lowercase). */
 	private final Map<String, ClientInfo> hClientList = new Hashtable<String, ClientInfo>();
 	/** Hashtable storing all known channels based on chanel name (inc prefix - in lowercase). */
-	private final Map<String, ChannelInfo> hChannelList = new Hashtable<String, ChannelInfo>();
+	private final Map<String, IRCChannelInfo> hChannelList = new Hashtable<String, IRCChannelInfo>();
 	/** Reference to the ClientInfo object that references ourself. */
 	private ClientInfo cMyself = new ClientInfo(this, "myself").setFake(true);
 	/** Hashtable storing all information gathered from 005. */
 		else { return new ClientInfo(this, sHost).setFake(true); }
 	}
 
-	/**
-	 * Get the ChannelInfo object for a channel.
-	 *
-	 * @param sWhat This is the name of the channel.
-	 * @return ChannelInfo Object for the channel, or null
-	 */
-	public ChannelInfo getChannelInfo(String sWhat) {
+	/** {@inheritDoc} */
+        @Override
+	public ChannelInfo getChannel(String channel) {
 		synchronized (hChannelList) {
-			sWhat = getIRCStringConverter().toLowerCase(sWhat);
-			if (hChannelList.containsKey(sWhat)) { return hChannelList.get(sWhat); } else { return null; }
+			channel = getIRCStringConverter().toLowerCase(channel);
+			if (hChannelList.containsKey(channel)) { return hChannelList.get(channel); } else { return null; }
 		}
 	}
 
 			// as the ircd will only reply once.
 			final LinkedList<Character> foundModes = new LinkedList<Character>();
 
-			final ChannelInfo channel = getChannelInfo(newLine[1]);
+			final ChannelInfo channel = getChannel(newLine[1]);
 			if (channel != null) {
 				final Queue<Character> listModeQueue = channel.getListModeQueue();
 				for (int i = 0; i < newLine[2].length() ; ++i) {
 	 * @param sReason Reason for leaving (Nothing sent if sReason is "")
 	 */
 	public void partChannel(final String sChannelName, final String sReason) {
-		if (getChannelInfo(sChannelName) == null) { return; }
+		if (getChannel(sChannelName) == null) { return; }
 		if (sReason.isEmpty()) {
 			sendString("PART " + sChannelName);
 		} else {
 	/** {@inheritDoc} */
     @Override
 	public void disconnect(final String message) {
-                if (currentSocketState == SocketState.OPEN) {
-                        currentSocketState = SocketState.CLOSING;
-                        if (got001) { quit(message); }
-                }
-
+                if (currentSocketState == SocketState.OPEN) {
+                        currentSocketState = SocketState.CLOSING;
+                        if (got001) { quit(message); }
+                }
+
 		try {
 			if (socket != null) { socket.close(); }
 		} catch (IOException e) {
 		// Check its not ourself (PM recieved before 005)
 		if (getIRCStringConverter().equalsIgnoreCase(getMyNickname(), sChannelName)) { return false; }
 		// Check if we are already on this channel
-		if (getChannelInfo(sChannelName) != null) { return true; }
+		if (getChannel(sChannelName) != null) { return true; }
 		// Check if we know of any valid chan prefixes
 		if (hChanPrefix.isEmpty()) {
 			// We don't. Lets check against RFC2811-Specified channel types
 	 *
 	 * @param channel Channel to add
 	 */
-	public void addChannel(final ChannelInfo channel) {
+	public void addChannel(final IRCChannelInfo channel) {
 		synchronized (hChannelList) {
 			hChannelList.put(getIRCStringConverter().toLowerCase(channel.getName()), channel);
 		}
 	 *
 	 * @param channel Channel to remove
 	 */
-	public void removeChannel(final ChannelInfo channel) {
+	public void removeChannel(final IRCChannelInfo channel) {
 		synchronized (hChannelList) {
 			hChannelList.remove(getIRCStringConverter().toLowerCase(channel.getName()));
 		}
 	 *
 	 * @return Known channels as a collection
 	 */
-	public Collection<ChannelInfo> getChannels() {
+	public Collection<IRCChannelInfo> getChannels() {
 		synchronized (hChannelList) {
 			return hChannelList.values();
 		}

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.irc.callbacks.CallbackManager;
 
 /**
 	/**
 	 * Get the ChannelInfo object for a channel.
 	 *
-	 * @param sWhat This is the name of the channel.
+	 * @param name This is the name of the channel.
 	 * @return ChannelInfo Object for the channel, or null
 	 */
-	protected final ChannelInfo getChannelInfo(final String sWhat) {
-		return myParser.getChannelInfo(sWhat);
+	protected final ChannelInfo getChannel(final String name) {
+		return myParser.getChannel(name);
 	}
 	
 	/**

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

 	public void process(final String sParam, final String[] token) {
 		if (sParam.equals("329")) {
 			if (token.length < 5) { return; }
-			ChannelInfo iChannel = myParser.getChannelInfo(token[3]);
+			IRCChannelInfo iChannel = myParser.getChannel(token[3]);
 			if (iChannel != null) {
 				try {
 					iChannel.setCreateTime(Integer.parseInt(token[4]));
 			Byte nTemp;
 			if (token.length < 3) { return; }
 			ClientInfo iClient;
-			ChannelInfo iChannel;
+			IRCChannelInfo iChannel;
 			ChannelClientInfo iChannelClient;
 			
 			iClient = myParser.getClientInfo(token[0]);
-			iChannel = myParser.getChannelInfo(token[token.length-1]);
+			iChannel = myParser.getChannel(token[token.length-1]);
 			
 			if (iClient == null) { 
 				iClient = new ClientInfo(myParser, token[0]);
 			//if (iClient != myParser.getMyself()) {
 				// callErrorInfo(new ParserError(ParserError.ERROR_WARNING, "Got join for channel ("+token[token.length-1]+") that I am not on. [Me: "+myParser.getMyself()+"]", myParser.getLastLine()));
 			//}
-			iChannel = new ChannelInfo(myParser, token[token.length-1]);
+			iChannel = new IRCChannelInfo(myParser, token[token.length-1]);
 			// Add ourself to the channel, this will be overridden by the NAMES reply
 			iChannel.addClient(iClient);
 			myParser.addChannel(iChannel);
 	 * @param cChannelClient ChannelClient object for new person
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelJoin(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient) {
+	protected boolean callChannelJoin(final IRCChannelInfo cChannel, final ChannelClientInfo cChannelClient) {
 		return getCallbackManager().getCallbackType(ChannelJoinListener.class).call(cChannel, cChannelClient);
 	}
 	
 	 * @param cChannel Channel Object
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelSelfJoin(final ChannelInfo cChannel) {
+	protected boolean callChannelSelfJoin(final IRCChannelInfo cChannel) {
 		return  getCallbackManager().getCallbackType(ChannelSelfJoinListener.class).call(cChannel);
 	}
 	

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.callbacks.ChannelKickListener;
 
 /**
 		
 		iClient = getClientInfo(token[3]);
 		iKicker = getClientInfo(token[0]);
-		iChannel = getChannelInfo(token[2]);
+		iChannel = getChannel(token[2]);
 		
 		if (iClient == null) { return; }
 		
 	 * @param sKickedByHost Hostname of Kicker (or servername)
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelKick(ChannelInfo cChannel, ChannelClientInfo cKickedClient, ChannelClientInfo cKickedByClient, String sReason, String sKickedByHost) {
+	protected boolean callChannelKick(IRCChannelInfo cChannel, ChannelClientInfo cKickedClient, ChannelClientInfo cKickedByClient, String sReason, String sKickedByHost) {
 		return getCallbackManager().getCallbackType(ChannelKickListener.class).call(cChannel, cKickedClient, cKickedByClient, sReason, sKickedByHost);
 	}
 	

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.callbacks.ChannelListModeListener;
 import java.util.List;
 import java.util.LinkedList;
 	@SuppressWarnings("unchecked")
 	@Override
 	public void process(String sParam, String[] token) {
-		ChannelInfo channel = getChannelInfo(token[3]);
+		ChannelInfo channel = getChannel(token[3]);
 		String thisIRCD = myParser.getIRCD(true).toLowerCase();
 		String item = "";
 		String owner = "";
 	 * @param cChannel Channel which the ListModes reply is for
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelGotListModes(ChannelInfo cChannel) {
+	protected boolean callChannelGotListModes(IRCChannelInfo cChannel) {
 		return getCallbackManager().getCallbackType(ChannelListModeListener.class).call(cChannel);
 	}
 	

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.callbacks.ChannelActionListener;
 import com.dmdirc.parser.interfaces.callbacks.ChannelCtcpListener;
 import com.dmdirc.parser.interfaces.callbacks.ChannelCtcpReplyListener;
 		final String targetName = (hasModePrefix) ? token[2].substring(1) : token[2];
 		
 		if (isValidChannelName(targetName)) {
-			iChannel = getChannelInfo(targetName);
+			iChannel = getChannel(targetName);
 			if (iChannel == null) {
 				// callErrorInfo(new ParserError(ParserError.ERROR_WARNING, "Got message for channel ("+targetName+") that I am not on.", myParser.getLastLine()));
 				return;
 	 * @param sHost Hostname of sender (or servername)
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelAction(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
+	protected boolean callChannelAction(final IRCChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
 		return getCallbackManager().getCallbackType(ChannelActionListener.class).call(cChannel, cChannelClient, sMessage, sHost);
 	}
 	
 	 * @param sHost Hostname of sender (or servername)
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelCTCP(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sType, final String sMessage, final String sHost) {
+	protected boolean callChannelCTCP(final IRCChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sType, final String sMessage, final String sHost) {
 		return getCallbackManager().getCallbackType(ChannelCtcpListener.class).call(cChannel, cChannelClient, sType, sMessage, sHost);
 	}
 
 	 * @param sHost Hostname of sender (or servername)
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelCTCPReply(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sType, final String sMessage, final String sHost) {
+	protected boolean callChannelCTCPReply(final IRCChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sType, final String sMessage, final String sHost) {
 		return getCallbackManager().getCallbackType(ChannelCtcpReplyListener.class).call(cChannel, cChannelClient, sType, sMessage, sHost);
 	}
 	
 	 * @param sHost Hostname of sender (or servername)
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelMessage(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
+	protected boolean callChannelMessage(final IRCChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
 		return getCallbackManager().getCallbackType(ChannelMessageListener.class).call(cChannel, cChannelClient, sMessage, sHost);
 	}
 	
 	 * @param sHost Hostname of sender (or servername)
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelNotice(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
+	protected boolean callChannelNotice(final IRCChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
 		return getCallbackManager().getCallbackType(ChannelNoticeListener.class).call(cChannel, cChannelClient, sMessage, sHost);
 	}
 	
 	 * @param sHost Hostname of sender (or servername)
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelModeNotice(final char prefix, final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
+	protected boolean callChannelModeNotice(final char prefix, final IRCChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
 		return getCallbackManager().getCallbackType(ChannelModeNoticeListener.class).call(prefix, cChannel, cChannelClient, sMessage, sHost);
 	}
 	
 	 * @param sHost Hostname of sender (or servername)
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelModeMessage(final char prefix, final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
+	protected boolean callChannelModeMessage(final char prefix, final IRCChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
 		return getCallbackManager().getCallbackType(ChannelModeMessageListener.class).call(prefix, cChannel, cChannelClient, sMessage, sHost);
 	}
 	

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.callbacks.ChannelModeChangeListener;
 import com.dmdirc.parser.interfaces.callbacks.ChannelNonUserModeChangeListener;
 import com.dmdirc.parser.interfaces.callbacks.ChannelSingleModeChangeListener;
 			cbNonUser = getCallbackManager().getCallbackType(ChannelNonUserModeChangeListener.class);
 		}
 		
-		iChannel = getChannelInfo(sChannelName);
+		iChannel = getChannel(sChannelName);
 		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);
 	 * @param sModes Exact String parsed
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelModeChanged(ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sHost, String sModes) {
+	protected boolean callChannelModeChanged(IRCChannelInfo cChannel, ChannelClientInfo cChannelClient, String sHost, String sModes) {
 		return getCallbackManager().getCallbackType(ChannelModeChangeListener.class).call(cChannel, cChannelClient, sHost, sModes);
 	}
 	
 	 * @param sHost Host doing the mode changing (User host or server name)
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelUserModeChanged(ChannelInfo cChannel, ChannelClientInfo cChangedClient, ChannelClientInfo cSetByClient, String sHost, String sMode) {
+	protected boolean callChannelUserModeChanged(IRCChannelInfo cChannel, ChannelClientInfo cChangedClient, ChannelClientInfo cSetByClient, String sHost, String sMode) {
 		return getCallbackManager().getCallbackType(ChannelUserModeChangeListener.class).call(cChannel, cChangedClient, cSetByClient, sHost, sMode);
 	}
 	

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.callbacks.ChannelNamesListener;
 
 /**
 		ChannelInfo iChannel;
 		if (sParam.equals("366")) {
 			// End of names
-			iChannel = getChannelInfo(token[3]);
+			iChannel = getChannel(token[3]);
 			if (iChannel == null) { return; }
 			
 			iChannel.setAddingNames(false);
 			ClientInfo iClient;
 			ChannelClientInfo iChannelClient;
 			
-			iChannel = getChannelInfo(token[4]);
+			iChannel = getChannel(token[4]);
 		
 			if (iChannel == null) { return; }
 			
 	 * @param cChannel Channel which the names reply is for
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelGotNames(ChannelInfo cChannel) {
+	protected boolean callChannelGotNames(IRCChannelInfo cChannel) {
 		return getCallbackManager().getCallbackType(ChannelNamesListener.class).call(cChannel);
 	}
 	

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

 					myParser.addClient(iClient);
 				}
 				
-				for (ChannelInfo iChannel : myParser.getChannels()) {
+				for (IRCChannelInfo iChannel : myParser.getChannels()) {
 					// Find the user (using the old nickname)
 					iChannelClient = iChannel.getUser(oldNickname);
 					if (iChannelClient != null) {
 	 * @param sOldNick Nickname before change
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelNickChanged(ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sOldNick) {
+	protected boolean callChannelNickChanged(IRCChannelInfo cChannel, ChannelClientInfo cChannelClient, String sOldNick) {
 		return getCallbackManager().getCallbackType(ChannelNickChangeListener.class).call(cChannel, cChannelClient, sOldNick);
 	}
 	

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.callbacks.ChannelPartListener;
 
 /**
 		ChannelClientInfo iChannelClient;
 		
 		iClient = getClientInfo(token[0]);
-		iChannel = getChannelInfo(token[2]);
+		iChannel = getChannel(token[2]);
 		
 		if (iClient == null) { return; }
 		if (IRCParser.ALWAYS_UPDATECLIENT && iClient.getHost().isEmpty()) {
 	 * @param sReason Reason given for parting (May be "")
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelPart(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sReason) {
+	protected boolean callChannelPart(final IRCChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sReason) {
 		return getCallbackManager().getCallbackType(ChannelPartListener.class).call(cChannel, cChannelClient, sReason);
 	}
 	

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

 		String sReason = "";
 		if (token.length > 2) { sReason = token[token.length-1]; }
 		
-		ArrayList<ChannelInfo> channelList = new ArrayList<ChannelInfo>(myParser.getChannels());
-		for (ChannelInfo iChannel : channelList) {
+		ArrayList<IRCChannelInfo> channelList = new ArrayList<IRCChannelInfo>(myParser.getChannels());
+		for (IRCChannelInfo iChannel : channelList) {
 			iChannelClient = iChannel.getUser(iClient);
 			if (iChannelClient != null) {
 				if (myParser.removeAfterCallback) { callChannelQuit(iChannel,iChannelClient,sReason); }
 	 * @param sReason Quit reason
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelQuit(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sReason) {
+	protected boolean callChannelQuit(final IRCChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sReason) {
 		return getCallbackManager().getCallbackType(ChannelQuitListener.class).call(cChannel, cChannelClient, sReason);
 	}
 	

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.callbacks.ChannelTopicListener;
 
 /**
 	public void process(final String sParam, final String[] token) {
 		ChannelInfo iChannel;
 		if (sParam.equals("332")) {
-			iChannel = getChannelInfo(token[3]);
+			iChannel = getChannel(token[3]);
 			if (iChannel == null) { return; }
 			iChannel.setTopic(token[token.length-1]);
 		} else if (sParam.equals("333")) {
 			if (token.length > 3) {
-				iChannel = getChannelInfo(token[3]);
+				iChannel = getChannel(token[3]);
 				if (iChannel == null) { return; }
 				if (token.length > 4) {
 					iChannel.setTopicUser(token[4]);
 				final ClientInfo iClient = getClientInfo(token[0]);
 				if (iClient != null && iClient.getHost().isEmpty()) {iClient.setUserBits(token[0],false); }
 			}
-			iChannel = getChannelInfo(token[2]);
+			iChannel = getChannel(token[2]);
 			if (iChannel == null) { return; }
 			iChannel.setTopicTime(System.currentTimeMillis() / 1000);
 			if (token[0].charAt(0) == ':') { token[0] = token[0].substring(1); }

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

 		// :server 352 mynickname channel username address server nick flags :hops info
 		//     0    1      2         3     4          5      6      7    8        9
 		
-//		ChannelInfo channel = myParser.getChannelInfo(token[3]);
-//		ChannelClientInfo channelClient = channel.getUser(token[7]);
-//		ClientInfo client = channelClient.getClient();
 		final ClientInfo client = myParser.getClientInfo(token[7]);
 		if (client != null) {
 			// Update ident/host
 			final String mode = token[8];
 			final boolean isAway = mode.indexOf('G') != -1;
 			if (client.getAwayState() != isAway) {
-//				System.out.println("Away state for '"+client+"' changed to: "+isAway);
 				client.setAwayState(isAway);
 				if (!isAway) { client.setAwayReason(""); }
 				if (client == myParser.getMyself()) {
 					callAwayStateOther(client, isAway);
 					
 					ChannelClientInfo iChannelClient;
-					for (ChannelInfo iChannel : myParser.getChannels()) {
+					for (IRCChannelInfo iChannel : myParser.getChannels()) {
 						iChannelClient = iChannel.getUser(client);
 						if (iChannelClient != null) {
 							callChannelAwayStateOther(iChannel,iChannelClient,isAway);
 	 * @param state Away State (true if away, false if here)
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelAwayStateOther(final ChannelInfo channel, final ChannelClientInfo channelClient, final boolean state) {
+	protected boolean callChannelAwayStateOther(final IRCChannelInfo channel, final ChannelClientInfo channelClient, final boolean state) {
 		return getCallbackManager().getCallbackType(ChannelOtherAwayStateListener.class).call(channel, channelClient, state);
 	}
 	

src/com/dmdirc/parser/irc/callbacks/CallbackObjectSpecific.java

 package com.dmdirc.parser.irc.callbacks;
 
 import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.ClientInfo;
 import com.dmdirc.parser.irc.ParserError;
 import com.dmdirc.parser.interfaces.callbacks.CallbackInterface;
 	 * @param cChannel ChannelInfo object for the channel to test
 	 * @return true if channel given matches the specifics for the method given
 	 */
-	protected boolean isValidChan(final CallbackInterface eMethod, final ChannelInfo cChannel) {
+	protected boolean isValidChan(final CallbackInterface eMethod, final IRCChannelInfo cChannel) {
 		if (specificData.containsKey(eMethod)) { 
 			if (!myParser.getIRCStringConverter().equalsIgnoreCase(cChannel.getName(), specificData.get(eMethod))) { return false; }
 		}
             if (type.isAnnotationPresent(SpecificCallback.class) &&
                     ((args[0] instanceof ClientInfo
                         && !isValidUser(iface, ((ClientInfo) args[0]).getHost()))
-                        || (args[0] instanceof ChannelInfo
-                        && !isValidChan(iface, (ChannelInfo) args[0]))
-                        || (!(args[0] instanceof ClientInfo || args[0] instanceof ChannelInfo) &&
+                        || (args[0] instanceof IRCChannelInfo
+                        && !isValidChan(iface, (IRCChannelInfo) args[0]))
+                        || (!(args[0] instanceof ClientInfo || args[0] instanceof IRCChannelInfo) &&
                         args[args.length - 1] instanceof String
                         && !isValidUser(iface, (String) args[args.length - 1])))) {
                 continue;

test/com/dmdirc/addons/logging/LoggingPluginTest.java

 import com.dmdirc.config.IdentityManager;
 import com.dmdirc.harness.TestLoggingPlugin;
 import com.dmdirc.harness.parser.TestParserFactory;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.addons.ui_dummy.DummyController;
 import com.dmdirc.plugins.PluginInfo;
 import com.dmdirc.util.ConfigFile;
         server = new Server("255.255.255.255", 6667, "", false,
                 IdentityManager.getProfiles().get(0), new ArrayList<String>(),
                 new TestParserFactory());
-        channel = new Channel(server, new ChannelInfo(server.getParser(), "#test"));
+        channel = new Channel(server, new IRCChannelInfo(server.getParser(), "#test"));
         query = new Query(server, "foo!bar@baz");
 
         final ConfigFile file = new ConfigFile(LoggingPlugin.class

test/com/dmdirc/commandparser/commands/channel/KickReasonTest.java

 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.config.ConfigManager;
 import com.dmdirc.parser.irc.ChannelClientInfo;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.ui.interfaces.InputWindow;
 
 import org.junit.BeforeClass;
     @Test
     public void testUnknown() {
         final InputWindow tiw = mock(InputWindow.class);
-        final ChannelInfo channelInfo = mock(ChannelInfo.class);
+        final IRCChannelInfo channelInfo = mock(IRCChannelInfo.class);
         final Channel channel = mock(Channel.class);
 
         when(channel.getChannelInfo()).thenReturn(channelInfo);
     @Test
     public void testWithReason() {
         final InputWindow tiw = mock(InputWindow.class);
-        final ChannelInfo channelInfo = mock(ChannelInfo.class);
+        final IRCChannelInfo channelInfo = mock(IRCChannelInfo.class);
         final Channel channel = mock(Channel.class);
         final ChannelClientInfo cci = mock(ChannelClientInfo.class);
 
     public void testWithoutReason() {
         final InputWindow tiw = mock(InputWindow.class);
         final ConfigManager manager = mock(ConfigManager.class);
-        final ChannelInfo channelInfo = mock(ChannelInfo.class);
+        final IRCChannelInfo channelInfo = mock(IRCChannelInfo.class);
         final Channel channel = mock(Channel.class);
         final ChannelClientInfo cci = mock(ChannelClientInfo.class);
 

test/com/dmdirc/commandparser/commands/channel/ModeTest.java

 import com.dmdirc.Server;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.config.IdentityManager;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.IRCParser;
 import com.dmdirc.ui.interfaces.InputWindow;
 
 public class ModeTest {
 
     private final Mode command = new Mode();
-    private ChannelInfo channelinfo;
+    private IRCChannelInfo channelinfo;
     private Channel channel;
     private Server server;
     private IRCParser parser;
         parser = mock(IRCParser.class);
         server = mock(Server.class);
         channel = mock(Channel.class);
-        channelinfo = mock(ChannelInfo.class);
+        channelinfo = mock(IRCChannelInfo.class);
 
         when(server.getParser()).thenReturn(parser);
         when(channel.getChannelInfo()).thenReturn(channelinfo);

test/com/dmdirc/commandparser/commands/channel/NamesTest.java

 import com.dmdirc.Server;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.config.IdentityManager;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.IRCParser;
 
 import org.junit.Before;
 public class NamesTest {
 
     private final Names command = new Names();
-    private ChannelInfo channelinfo;
+    private IRCChannelInfo channelinfo;
     private Channel channel;
     private Server server;
     private IRCParser parser;
         parser = mock(IRCParser.class);
         server = mock(Server.class);
         channel = mock(Channel.class);
-        channelinfo = mock(ChannelInfo.class);
+        channelinfo = mock(IRCChannelInfo.class);
 
         when(server.getParser()).thenReturn(parser);
         when(channel.getChannelInfo()).thenReturn(channelinfo);

test/com/dmdirc/commandparser/commands/channel/PartTest.java

 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.config.ConfigManager;
 import com.dmdirc.config.IdentityManager;
-import com.dmdirc.parser.irc.ChannelInfo;
+import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.IRCParser;
 import com.dmdirc.ui.interfaces.InputWindow;
 

test/com/dmdirc/harness/parser/TestIChannelPart.java

 
 public class TestIChannelPart implements ChannelPartListener {
 
-    public ChannelInfo channel;
+    public IRCChannelInfo channel;
 
     public ChannelClientInfo cclient;
 
     public String reason;
 
-    public void onChannelPart(IRCParser tParser, ChannelInfo cChannel,
+    public void onChannelPart(IRCParser tParser, IRCChannelInfo cChannel,
                               ChannelClientInfo cChannelClient, String sReason) {
         channel = cChannel;
         cclient = cChannelClient;

test/com/dmdirc/harness/parser/TestIChannelSelfJoin.java

 
 public class TestIChannelSelfJoin implements ChannelSelfJoinListener {
 
-    public ChannelInfo channel = null;
+    public IRCChannelInfo channel = null;
 
-    public void onChannelSelfJoin(IRCParser tParser, ChannelInfo cChannel) {
+    public void onChannelSelfJoin(IRCParser tParser, IRCChannelInfo cChannel) {
         channel = cChannel;
     }
 }

test/com/dmdirc/harness/parser/TestIChannelTopic.java

 
     public boolean isJoin;
 
-    public ChannelInfo channel;
+    public IRCChannelInfo channel;
 
-    public void onChannelTopic(IRCParser tParser, ChannelInfo cChannel,
+    public void onChannelTopic(IRCParser tParser, IRCChannelInfo cChannel,
                                boolean bIsJoinTopic) {
         triggered = true;
         isJoin = bIsJoinTopic;

test/com/dmdirc/harness/parser/TestIQuit.java

 
 public class TestIQuit implements ChannelQuitListener, QuitListener {
 
-    public ChannelInfo channel;
+    public IRCChannelInfo channel;
 
     public ChannelClientInfo cclient;
 
 
     public int count = 0;
 
-    public void onChannelQuit(IRCParser tParser, ChannelInfo cChannel,
+    public void onChannelQuit(IRCParser tParser, IRCChannelInfo cChannel,
                               ChannelClientInfo cChannelClient, String sReason) {
         this.channel = cChannel;
         this.cclient = cChannelClient;

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

 
 import com.dmdirc.harness.parser.TestParser;
 
+import com.dmdirc.parser.interfaces.ChannelInfo;
 import java.util.HashMap;
 import java.util.Map;
 
 
 public class ChannelInfoTest {
 
-    final ChannelInfo ci = new ChannelInfo(null, "name");
+    final IRCChannelInfo ci = new IRCChannelInfo(null, "name");
 
     @Test
     public void testGetName() {
     @Test
     public void testSendMessage() {
         final TestParser parser = new TestParser();
-        getChannelInfo(parser).sendMessage("hello");
+        getChannel(parser).sendMessage("hello");
 
         assertEquals("PRIVMSG #DMDirc_testing :hello", parser.sentLines.get(0));
     }
     @Test
     public void testSendNotice() {
         final TestParser parser = new TestParser();
-        getChannelInfo(parser).sendNotice("hello");
+        getChannel(parser).sendNotice("hello");
 
         assertEquals("NOTICE #DMDirc_testing :hello", parser.sentLines.get(0));
     }
     @Test
     public void testSendCTCP() {
         final TestParser parser = new TestParser();
-        getChannelInfo(parser).sendCTCP("type", "hello");
+        getChannel(parser).sendCTCP("type", "hello");
 
         assertEquals("PRIVMSG #DMDirc_testing :" + ((char) 1) + "TYPE hello" + ((char) 1),
                 parser.sentLines.get(0));
     @Test
     public void testSendCTCPEmpty() {
         final TestParser parser = new TestParser();
-        getChannelInfo(parser).sendCTCP("type", "");
+        getChannel(parser).sendCTCP("type", "");
 
         assertEquals("PRIVMSG #DMDirc_testing :" + ((char) 1) + "TYPE" + ((char) 1),
                 parser.sentLines.get(0));
     @Test
     public void testSendAction() {
         final TestParser parser = new TestParser();
-        getChannelInfo(parser).sendAction("moo");
+        getChannel(parser).sendAction("moo");
 
         assertEquals("PRIVMSG #DMDirc_testing :" + ((char) 1) + "ACTION moo" + ((char) 1),
                 parser.sentLines.get(0));
     @Test
     public void testSendCTCPReply() {
         final TestParser parser = new TestParser();
-        getChannelInfo(parser).sendCTCPReply("type", "moo");
+        getChannel(parser).sendCTCPReply("type", "moo");
 
         assertEquals("NOTICE #DMDirc_testing :" + ((char) 1) + "TYPE moo" + ((char) 1),
                 parser.sentLines.get(0));
     @Test
     public void testSendCTCPReplyEmpty() {
         final TestParser parser = new TestParser();
-        getChannelInfo(parser).sendCTCPReply("type", "");
+        getChannel(parser).sendCTCPReply("type", "");
 
         assertEquals("NOTICE #DMDirc_testing :" + ((char) 1) + "TYPE" + ((char) 1),
                 parser.sentLines.get(0));
     @Test
     public void testSendEmptyMessages() {
         final TestParser parser = new TestParser();
-        final ChannelInfo info = getChannelInfo(parser);
+        final ChannelInfo info = getChannel(parser);
         
         info.sendAction("");
         info.sendCTCP("", "");
     @Test
     public void testGetSetParamMode() {
         final TestParser parser = new TestParser();
-        final ChannelInfo info = getChannelInfo(parser);
+        final ChannelInfo info = getChannel(parser);
         parser.injectLine(":server 324 nick #DMDirc_testing +k lalala");
         parser.sentLines.clear();
         
     @Test
     public void testModeSendFull() {
         final TestParser parser = new TestParser();
-        final ChannelInfo info = getChannelInfo(parser);
+        final ChannelInfo info = getChannel(parser);
 
         parser.sentLines.clear();
         info.alterMode(true, 'i', null);
     @Test
     public void testModeSendExtra() {
         final TestParser parser = new TestParser();
-        final ChannelInfo info = getChannelInfo(parser);
+        final ChannelInfo info = getChannel(parser);
 
         parser.sentLines.clear();
         info.alterMode(true, 'i', null);
     @Test
     public void testModeSendOptimisation1() {
         final TestParser parser = new TestParser();
-        final ChannelInfo info = getChannelInfo(parser);
+        final ChannelInfo info = getChannel(parser);
 
         parser.sentLines.clear();
         info.alterMode(true, 'i', null);
     @Test
     public void testModeSendOptimisation2() {
         final TestParser parser = new TestParser();
-        final ChannelInfo info = getChannelInfo(parser);
+        final ChannelInfo info = getChannel(parser);
 
         parser.sentLines.clear();
         info.alterMode(true, 'm', null);
     @Test
     public void testModeUnsetKey() {
         final TestParser parser = new TestParser();
-        final ChannelInfo info = getChannelInfo(parser);
+        final ChannelInfo info = getChannel(parser);
         parser.injectLine(":server 324 nick #DMDirc_testing +k lalala");
         parser.sentLines.clear();
         
         parser.injectLine(":foo!bar@baz JOIN #DMDirc_testing");
         parser.injectLine(":flub!floo@fleeee JOIN #DMDirc_testing");
 
-        assertNotSame(parser.getChannelInfo("#DMDirc_testing").getChannelClients(),
-                parser.getChannelInfo("#DMDirc_testing").getChannelClients());
-        assertEquals(parser.getChannelInfo("#DMDirc_testing").getChannelClients(),
-                parser.getChannelInfo("#DMDirc_testing").getChannelClients());
+        assertNotSame(parser.getChannel("#DMDirc_testing").getChannelClients(),
+                parser.getChannel("#DMDirc_testing").getChannelClients());
+        assertEquals(parser.getChannel("#DMDirc_testing").getChannelClients(),
+                parser.getChannel("#DMDirc_testing").getChannelClients());
     }
     
     @Test @Ignore
     public void testModeUnsetKeyMultiple() {
         final TestParser parser = new TestParser();
-        final ChannelInfo info = getChannelInfo(parser);
+        final ChannelInfo info = getChannel(parser);
         parser.injectLine(":server 324 nick #DMDirc_testing +k lalala");
         parser.sentLines.clear();
         
     @Test @Ignore
     public void testModeUnsetLimitMultiple() {
         final TestParser parser = new TestParser();
-        final ChannelInfo info = getChannelInfo(parser);
+        final ChannelInfo info = getChannel(parser);
         parser.injectLine(":server 324 nick #DMDirc_testing +l 73");
         parser.sentLines.clear();
         
         return res;
     }
 
-    private ChannelInfo getChannelInfo(final TestParser parser) {
+    private ChannelInfo getChannel(final TestParser parser) {
         parser.injectConnectionStrings();
         parser.injectLine(":nick JOIN #DMDirc_testing");
 

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

         parser.injectLine(":server " + numeric2 + " nick #D :End of Channel Something List");
 
         final List<ChannelListModeItem> items
-                = parser.getChannelInfo("#D").getListModeParam(mode);
+                = parser.getChannel("#D").getListModeParam(mode);
 
         assertEquals(3, items.size());
         boolean gotOne = false, gotTwo = false, gotThree = false;
         parser.getCallbackManager().addCallback(ChannelKickListener.class, ick, "#D");
         parser.injectLine(":bar!me@moo KICK #D nick :Bye!");
 
-        verify(ick).onChannelKick(same(parser), (ChannelInfo) anyObject(),
+        verify(ick).onChannelKick(same(parser), (IRCChannelInfo) anyObject(),
                 (ChannelClientInfo) anyObject(), (ChannelClientInfo) anyObject(),
                 anyString(), anyString());
     }

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

         assertSame(parser, test.channel.getParser());
         assertEquals(1, parser.getChannels().size());
         assertTrue(parser.getChannels().contains(test.channel));
-        assertEquals(test.channel, parser.getChannelInfo("#DMDirc_testing"));
+        assertEquals(test.channel, parser.getChannel("#DMDirc_testing"));
     }
     
     @Test
         parser.injectLine(":nick JOIN #DMDirc_testing");
         parser.injectLine(":foo!bar@baz JOIN #DMDirc_testing");
 
-        verify(test).onChannelJoin(parser, parser.getChannelInfo("#DMDirc_testing"),
+        verify(test).onChannelJoin(parser, parser.getChannel("#DMDirc_testing"),
                 parser.getClientInfo("foo!bar@baz").getChannelClients().get(0));
     }    
 

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

         parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list");
         parser.injectLine(":server 324 nick #DMDirc_testing +Zstnl 1234");
 
-        assertEquals("1234", parser.getChannelInfo("#DMDirc_testing").getModeParam('l'));
+        assertEquals("1234", parser.getChannel("#DMDirc_testing").getModeParam('l'));
         
-        String modes = parser.getChannelInfo("#DMDirc_testing").getModeStr().split(" ")[0];
+        String modes = parser.getChannel("#DMDirc_testing").getModeStr().split(" ")[0];
         assertEquals(6, modes.length());
         assertEquals('+', modes.charAt(0));
         assertTrue(modes.indexOf('Z') > -1);
         
         parser.injectLine(":server MODE #DMDirc_testing :-Z");
         
-        modes = parser.getChannelInfo("#DMDirc_testing").getModeStr().split(" ")[0];
+        modes = parser.getChannel("#DMDirc_testing").getModeStr().split(" ")[0];
         assertEquals(5, modes.length());
         assertEquals('+', modes.charAt(0));
         assertTrue(modes.indexOf('s') > -1);

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

         parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list");
 
         assertEquals(1, parser.getChannels().size());
-        assertNotNull(parser.getChannelInfo("#DMDirc_testing"));
-        assertEquals(4, parser.getChannelInfo("#DMDirc_testing").getChannelClients().size());
+        assertNotNull(parser.getChannel("#DMDirc_testing"));
+        assertEquals(4, parser.getChannel("#DMDirc_testing").getChannelClients().size());
         assertNotNull(parser.getClientInfo("luser"));
         assertEquals(1, parser.getClientInfo("luser").getChannelClients().size());
 
         ChannelClientInfo cci = parser.getClientInfo("luser").getChannelClients().get(0);
-        assertEquals(parser.getChannelInfo("#DMDirc_testing"), cci.getChannel());
+        assertEquals(parser.getChannel("#DMDirc_testing"), cci.getChannel());
         assertEquals("+", cci.getChanModeStr(true));
         
-        cci = parser.getChannelInfo("#DMDirc_testing").getUser("nick2");
+        cci = parser.getChannel("#DMDirc_testing").getUser("nick2");
         assertNotNull(cci);
         assertEquals("@+", cci.getChanModeStr(true));
 
-        cci = parser.getChannelInfo("#DMDirc_testing").getUser("nick3");
+        cci = parser.getChannel("#DMDirc_testing").getUser("nick3");
         assertNotNull(cci);
         assertEquals("", cci.getChanModeStr(true));
     }

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

         assertEquals(1, parser.getClientInfo("LUSER").getChannelClients().size());
 
         ChannelClientInfo cci = parser.getClientInfo("LUSER").getChannelClients().get(0);
-        assertEquals(parser.getChannelInfo("#DMDirc_testing"), cci.getChannel());
+        assertEquals(parser.getChannel("#DMDirc_testing"), cci.getChannel());
         assertEquals("+", cci.getChanModeStr(true));
         
         assertSame(cci.getClient(), tinc.client);
         assertEquals(1, parser.getClientInfo("foobar").getChannelClients().size());
 
         ChannelClientInfo cci = parser.getClientInfo("foobar").getChannelClients().get(0);
-        assertEquals(parser.getChannelInfo("#DMDirc_testing"), cci.getChannel());
+        assertEquals(parser.getChannel("#DMDirc_testing"), cci.getChannel());
         assertEquals("+", cci.getChanModeStr(true));
     }    
     

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

         final TestIChannelPart test = new TestIChannelPart();
         parser.getCallbackManager().addCallback(ChannelPartListener.class, test);
         
-        assertEquals(2, parser.getChannelInfo("#DMDirc_testing").getChannelClients().size());
+        assertEquals(2, parser.getChannel("#DMDirc_testing").getChannelClients().size());
         
         parser.injectLine(":luser!foo@barsville PART #DMDirc_testing :Bye bye, cruel world");
         
-        assertEquals(1, parser.getChannelInfo("#DMDirc_testing").getChannelClients().size());
+        assertEquals(1, parser.getChannel("#DMDirc_testing").getChannelClients().size());
         
         assertNotNull(test.channel);
         assertNotNull(test.cclient);
         final TestIChannelPart test = new TestIChannelPart();
         parser.getCallbackManager().addCallback(ChannelPartListener.class, test);
         
-        assertEquals(2, parser.getChannelInfo("#DMDirc_testing").getChannelClients().size());
+        assertEquals(2, parser.getChannel("#DMDirc_testing").getChannelClients().size());
         
         parser.injectLine(":luser!foo@barsville PART #DMDirc_testing");
         
-        assertEquals(1, parser.getChannelInfo("#DMDirc_testing").getChannelClients().size());
+        assertEquals(1, parser.getChannel("#DMDirc_testing").getChannelClients().size());
         
         assertNotNull(test.channel);
         assertNotNull(test.cclient);

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

         final TestIQuit test = new TestIQuit();
         parser.getCallbackManager().addCallback(ChannelQuitListener.class, test);
         
-        assertEquals(2, parser.getChannelInfo("#DMDirc_testing").getChannelClients().size());
+        assertEquals(2, parser.getChannel("#DMDirc_testing").getChannelClients().size());
         
         parser.injectLine(":luser!foo@barsville QUIT :Bye bye, cruel world");
         
-        assertEquals(1, parser.getChannelInfo("#DMDirc_testing").getChannelClients().size());
-        assertEquals(2, parser.getChannelInfo("#DMDirc_testing2").getChannelClients().size());
+        assertEquals(1, parser.getChannel("#DMDirc_testing").getChannelClients().size());
+        assertEquals(2, parser.getChannel("#DMDirc_testing2").getChannelClients().size());
         
         assertNotNull(test.channel);
         assertNotNull(test.cclient);
         final TestIQuit test = new TestIQuit();
         parser.getCallbackManager().addCallback(QuitListener.class, test);
         
-        assertEquals(2, parser.getChannelInfo("#DMDirc_testing").getChannelClients().size());
+        assertEquals(2, parser.getChannel("#DMDirc_testing").getChannelClients().size());
         
         parser.injectLine(":luser!foo@barsville QUIT :Bye bye, cruel world");
         
-        assertEquals(1, parser.getChannelInfo("#DMDirc_testing").getChannelClients().size());
-        assertEquals(2, parser.getChannelInfo("#DMDirc_testing2").getChannelClients().size());
+        assertEquals(1, parser.getChannel("#DMDirc_testing").getChannelClients().size());
+        assertEquals(2, parser.getChannel("#DMDirc_testing2").getChannelClients().size());
         
         assertNotNull(test.client);
         assertNotNull(test.reason);
         final TestIQuit test = new TestIQuit();
         parser.getCallbackManager().addCallback(QuitListener.class, test);
         
-        assertEquals(2, parser.getChannelInfo("#DMDirc_testing").getChannelClients().size());
+        assertEquals(2, parser.getChannel("#DMDirc_testing").getChannelClients().size());
         
         parser.injectLine(":luser!foo@barsville QUIT");
         
-        assertEquals(1, parser.getChannelInfo("#DMDirc_testing").getChannelClients().size());
+        assertEquals(1, parser.getChannel("#DMDirc_testing").getChannelClients().size());
         
         assertNotNull(test.client);
         assertNotNull(test.reason);