Parser abstraction part 2. The parser now works.

src/com/dmdirc/ChannelEventHandler.java

     }
 
     /** {@inheritDoc} */
+    @SuppressWarnings("unchecked")
     @Override
-    protected void addCallback(final CallbackManager cbm, final String name)
-            throws CallbackNotFoundException {
-        if ("onAwayStateOther".equals(name)) {
-            cbm.addCallback(name, this);
+    protected <T extends CallbackInterface> void addCallback(
+            final CallbackManager cbm, final Class<T> type) throws CallbackNotFoundException {
+        if (OtherAwayStateListener.class.equals(type)) {
+            cbm.addCallback(type, (T) this);
         } else {
-            cbm.addCallback(name, this, owner.getChannelInfo().getName());
+            cbm.addCallback(type, (T) this, owner.getChannelInfo().getName());
         }
     }
 

src/com/dmdirc/EventHandler.java

  */
 public abstract class EventHandler implements CallbackInterface {
     
-    /** The prefix indicating that the interface is a parser callback. */
-    private static final String CALLBACK_PREFIX = "com.dmdirc.parser.irc.callbacks.interfaces.I";
-    
     /**
      * Registers all callbacks that this event handler implements with the
      * owner's parser.
      */
+    @SuppressWarnings("unchecked")
     public void registerCallbacks() {
         final CallbackManager cbm = getServer().getParser().getCallbackManager();
         
         try {
             for (Class iface : this.getClass().getInterfaces()) {
-                if (iface.getName().startsWith(CALLBACK_PREFIX)) {
-                    addCallback(cbm, "on"
-                            + iface.getName().substring(CALLBACK_PREFIX.length()));
+                if (CallbackInterface.class.isAssignableFrom(iface)) {
+                    addCallback(cbm, iface);
                 }
             }
         } catch (CallbackNotFoundException exception) {
     /**
      * Adds a callback to this event handler.
      * 
+     * @param <T> The type of callback to be added
      * @param cbm The callback manager to use
-     * @param name The name of the callback to be added
+     * @param type The type of the callback to be added
      * @throws com.dmdirc.parser.irc.callbacks.CallbackNotFoundException
      * if the specified callback isn't found
      */
-    protected abstract void addCallback(CallbackManager cbm, String name) 
-            throws CallbackNotFoundException;
+    @SuppressWarnings("unchecked")
+    protected abstract <T extends CallbackInterface> void addCallback(
+            final CallbackManager cbm, final Class<T> type) throws CallbackNotFoundException;
     
     /**
      * Retrieves the server belonging to this EventHandler's owner.

src/com/dmdirc/Query.java

         final CallbackManager callbackManager = server.getParser().getCallbackManager();
 
         try {
-            callbackManager.addCallback("onPrivateAction", this, ClientInfo.parseHost(host));
-            callbackManager.addCallback("onPrivateMessage", this, ClientInfo.parseHost(host));
-            callbackManager.addCallback("onQuit", this);
-            callbackManager.addCallback("onNickChanged", this);
+            callbackManager.addCallback(PrivateActionListener.class, this, ClientInfo.parseHost(host));
+            callbackManager.addCallback(PrivateMessageListener.class, this, ClientInfo.parseHost(host));
+            callbackManager.addCallback(QuitListener.class, this);
+            callbackManager.addCallback(NickChangeListener.class, this);
         } catch (CallbackNotFoundException ex) {
             Logger.appError(ErrorLevel.HIGH, "Unable to get query events", ex);
         }
         if (sOldNick.equals(ClientInfo.parseHost(host))) {
             final CallbackManager callbackManager = server.getParser().getCallbackManager();
 
-            callbackManager.delCallback("onPrivateAction", this);
-            callbackManager.delCallback("onPrivateMessage", this);
+            callbackManager.delCallback(PrivateActionListener.class, this);
+            callbackManager.delCallback(PrivateMessageListener.class, this);
 
             try {
-                callbackManager.addCallback("onPrivateAction", this, cClient.getNickname());
-                callbackManager.addCallback("onPrivateMessage", this, cClient.getNickname());
+                callbackManager.addCallback(PrivateActionListener.class, this, cClient.getNickname());
+                callbackManager.addCallback(PrivateMessageListener.class, this, cClient.getNickname());
             } catch (CallbackNotFoundException ex) {
                 Logger.appError(ErrorLevel.HIGH, "Unable to get query events", ex);
             }

src/com/dmdirc/Raw.java

      */
     public void registerCallbacks() {
         try {
-            server.getParser().getCallbackManager().addCallback("OnDataIn", this);
-            server.getParser().getCallbackManager().addCallback("OnDataOut", this);
+            server.getParser().getCallbackManager().addCallback(DataInListener.class, this);
+            server.getParser().getCallbackManager().addCallback(DataOutListener.class, this);
         } catch (CallbackNotFoundException ex) {
             Logger.appError(ErrorLevel.HIGH, "Unable to register raw callbacks", ex);
         }

src/com/dmdirc/ServerEventHandler.java

 
     /** {@inheritDoc} */
     @Override
-    protected void addCallback(final CallbackManager cbm, final String name)
-            throws CallbackNotFoundException {
-        cbm.addCallback(name, this);
+    @SuppressWarnings("unchecked")
+    protected <T extends CallbackInterface> void addCallback(
+            final CallbackManager cbm, final Class<T> type) throws CallbackNotFoundException {
+        cbm.addCallback(type, (T) this);
     }
 
     /** {@inheritDoc} */

src/com/dmdirc/addons/dcc/DCCSendWindow.java

         this.myPlugin = plugin;
         
 		if (parser != null) {
-			parser.getCallbackManager().addNonCriticalCallback("onSocketClosed", this);
+			parser.getCallbackManager().addNonCriticalCallback(SocketCloseListener.class, this);
 		}
 		dcc.setHandler(this);
 

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.ConnectErrorListener;
+import com.dmdirc.parser.interfaces.callbacks.DataInListener;
+import com.dmdirc.parser.interfaces.callbacks.DataOutListener;
+import com.dmdirc.parser.interfaces.callbacks.DebugInfoListener;
+import com.dmdirc.parser.interfaces.callbacks.ErrorInfoListener;
+import com.dmdirc.parser.interfaces.callbacks.PingFailureListener;
+import com.dmdirc.parser.interfaces.callbacks.PingSentListener;
+import com.dmdirc.parser.interfaces.callbacks.PingSuccessListener;
+import com.dmdirc.parser.interfaces.callbacks.Post005Listener;
+import com.dmdirc.parser.interfaces.callbacks.ServerErrorListener;
+import com.dmdirc.parser.interfaces.callbacks.SocketCloseListener;
 import com.dmdirc.parser.irc.callbacks.CallbackManager;
 
 import java.io.BufferedReader;
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callServerError(final String message) {
-		return myCallbackManager.getCallbackType("OnServerError").call(message);
+		return myCallbackManager.getCallbackType(ServerErrorListener.class).call(message);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callDataIn(final String data) {
-		return myCallbackManager.getCallbackType("OnDataIn").call(data);
+		return myCallbackManager.getCallbackType(DataInListener.class).call(data);
 	}
 
 	/**
 	 * @see com.dmdirc.parser.irc.callbacks.interfaces.IDataOut
 	 */
 	protected boolean callDataOut(final String data, final boolean fromParser) {
-		return myCallbackManager.getCallbackType("OnDataOut").call(data, fromParser);
+		return myCallbackManager.getCallbackType(DataOutListener.class).call(data, fromParser);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callDebugInfo(final int level, final String data) {
-		return myCallbackManager.getCallbackType("OnDebugInfo").call(level, data);
+		return myCallbackManager.getCallbackType(DebugInfoListener.class).call(level, data);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callErrorInfo(final ParserError errorInfo) {
-		return myCallbackManager.getCallbackType("OnErrorInfo").call(errorInfo);
+		return myCallbackManager.getCallbackType(ErrorInfoListener.class).call(errorInfo);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callConnectError(final ParserError errorInfo) {
-		return myCallbackManager.getCallbackType("OnConnectError").call(errorInfo);
+		return myCallbackManager.getCallbackType(ConnectErrorListener.class).call(errorInfo);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callSocketClosed() {
-		return myCallbackManager.getCallbackType("OnSocketClosed").call();
+		return myCallbackManager.getCallbackType(SocketCloseListener.class).call();
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPingFailed() {
-		return myCallbackManager.getCallbackType("OnPingFailed").call();
+		return myCallbackManager.getCallbackType(PingFailureListener.class).call();
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPingSent() {
-		return myCallbackManager.getCallbackType("OnPingSent").call();
+		return myCallbackManager.getCallbackType(PingSentListener.class).call();
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPingSuccess() {
-		return myCallbackManager.getCallbackType("OnPingSuccess").call();
+		return myCallbackManager.getCallbackType(PingSuccessListener.class).call();
 	}
 
 	/**
 		if (!h005Info.containsKey("USERMODES")) { parseUserModes(); }
 		if (!h005Info.containsKey("CHANMODES")) { parseChanModes(); }
 
-		return getCallbackManager().getCallbackType("OnPost005").call();
+		return getCallbackManager().getCallbackType(Post005Listener.class).call();
 	}
 
 	//---------------------------------------------------------------------------

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.ServerReadyListener;
+
 /**
  * Process a 001 message.
  */
 	 * @return true if a method was called, false otherwise
 	 */	
 	protected boolean callServerReady() {
-		return getCallbackManager().getCallbackType("OnServerReady").call();
+		return getCallbackManager().getCallbackType(ServerReadyListener.class).call();
 	}
 	
 	/**

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.NetworkDetectedListener;
+
 /**
  * Process ISUPPORT lines.
  */
 		final String ircdVersion = myParser.getIRCD(false);
 		final String ircdType = myParser.getIRCD(true);
 		
-		return getCallbackManager().getCallbackType("OnGotNetwork").call(networkName, ircdVersion, ircdType);
+		return getCallbackManager().getCallbackType(NetworkDetectedListener.class).call(networkName, ircdVersion, ircdType);
 	}
 	
 	/**

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.PasswordRequiredListener;
+
 /**
  * Process a 464 message.
  */
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPasswordRequired() {
-		return getCallbackManager().getCallbackType("OnPasswordRequired").call();
+		return getCallbackManager().getCallbackType(PasswordRequiredListener.class).call();
 	}
 	
 	/**

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.AwayStateListener;
+
 /**
  * Process an Away/Back message.
  */
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callAwayState(boolean currentState, String reason) {
-		return myParser.getCallbackManager().getCallbackType("OnAwayState").call(currentState, reason);
+		return myParser.getCallbackManager().getCallbackType(AwayStateListener.class).call(currentState, reason);
 	}
 	
 	/**

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.InviteListener;
+
 /**
  * Process an Invite Request.
  */
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callInvite(final String userHost, final String channel) {
-		return getCallbackManager().getCallbackType("OnInvite").call(userHost, channel);
+		return getCallbackManager().getCallbackType(InviteListener.class).call(userHost, channel);
 	}
 	
 	/**

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.ChannelJoinListener;
+import com.dmdirc.parser.interfaces.callbacks.ChannelSelfJoinListener;
+
 /**
  * Process a channel join.
  */
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelJoin(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient) {
-		return getCallbackManager().getCallbackType("OnChannelJoin").call(cChannel, cChannelClient);
+		return getCallbackManager().getCallbackType(ChannelJoinListener.class).call(cChannel, cChannelClient);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelSelfJoin(final ChannelInfo cChannel) {
-		return  getCallbackManager().getCallbackType("OnChannelSelfJoin").call(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.callbacks.ChannelKickListener;
+
 /**
  * Process a channel kick.
  */
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelKick(ChannelInfo cChannel, ChannelClientInfo cKickedClient, ChannelClientInfo cKickedByClient, String sReason, String sKickedByHost) {
-		return getCallbackManager().getCallbackType("OnChannelKick").call(cChannel, cKickedClient, cKickedByClient, sReason, 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.callbacks.ChannelListModeListener;
 import java.util.List;
 import java.util.LinkedList;
 import java.util.Queue;
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelGotListModes(ChannelInfo cChannel) {
-		return getCallbackManager().getCallbackType("OnChannelGotListModes").call(cChannel);
+		return getCallbackManager().getCallbackType(ChannelListModeListener.class).call(cChannel);
 	}
 	
 	/**

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.MotdEndListener;
+import com.dmdirc.parser.interfaces.callbacks.MotdLineListener;
+import com.dmdirc.parser.interfaces.callbacks.MotdStartListener;
+
 /**
  * Process a MOTD Related Line.
  */
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callMOTDEnd(final boolean noMOTD, final String data) {
-		return getCallbackManager().getCallbackType("OnMOTDEnd").call(noMOTD, data);
+		return getCallbackManager().getCallbackType(MotdEndListener.class).call(noMOTD, data);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callMOTDLine(final String data) {
-		return getCallbackManager().getCallbackType("OnMOTDLine").call(data);
+		return getCallbackManager().getCallbackType(MotdLineListener.class).call(data);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callMOTDStart(String data) {
-		return getCallbackManager().getCallbackType("OnMOTDStart").call(data);
+		return getCallbackManager().getCallbackType(MotdStartListener.class).call(data);
 	}
 	
 	/**

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.ChannelActionListener;
+import com.dmdirc.parser.interfaces.callbacks.ChannelCtcpListener;
+import com.dmdirc.parser.interfaces.callbacks.ChannelCtcpReplyListener;
+import com.dmdirc.parser.interfaces.callbacks.ChannelMessageListener;
+import com.dmdirc.parser.interfaces.callbacks.ChannelNoticeListener;
+import com.dmdirc.parser.interfaces.callbacks.PrivateActionListener;
+import com.dmdirc.parser.interfaces.callbacks.PrivateCtcpListener;
+import com.dmdirc.parser.interfaces.callbacks.PrivateCtcpReplyListener;
+import com.dmdirc.parser.interfaces.callbacks.PrivateMessageListener;
+import com.dmdirc.parser.interfaces.callbacks.PrivateNoticeListener;
+import com.dmdirc.parser.interfaces.callbacks.UnknownActionListener;
+import com.dmdirc.parser.interfaces.callbacks.UnknownCtcpListener;
+import com.dmdirc.parser.interfaces.callbacks.UnknownCtcpReplyListener;
+import com.dmdirc.parser.interfaces.callbacks.UnknownMessageListener;
+import com.dmdirc.parser.interfaces.callbacks.UnknownNoticeListener;
 import java.util.regex.PatternSyntaxException;
 
 /**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelAction(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
-		return getCallbackManager().getCallbackType("OnChannelAction").call(cChannel, cChannelClient, sMessage, sHost);
+		return getCallbackManager().getCallbackType(ChannelActionListener.class).call(cChannel, cChannelClient, sMessage, sHost);
 	}
 	
 	/**
 	 * @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) {
-		return getCallbackManager().getCallbackType("OnChannelCTCP").call(cChannel, cChannelClient, sType, sMessage, sHost);
+		return getCallbackManager().getCallbackType(ChannelCtcpListener.class).call(cChannel, cChannelClient, sType, sMessage, sHost);
 	}
 
 	/**
 	 * @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) {
-		return getCallbackManager().getCallbackType("OnChannelCTCPReply").call(cChannel, cChannelClient, sType, sMessage, sHost);
+		return getCallbackManager().getCallbackType(ChannelCtcpReplyListener.class).call(cChannel, cChannelClient, sType, sMessage, sHost);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelMessage(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
-		return getCallbackManager().getCallbackType("OnChannelMessage").call(cChannel, cChannelClient, sMessage, sHost);
+		return getCallbackManager().getCallbackType(ChannelMessageListener.class).call(cChannel, cChannelClient, sMessage, sHost);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelNotice(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
-		return getCallbackManager().getCallbackType("OnChannelNotice").call(cChannel, cChannelClient, sMessage, sHost);
+		return getCallbackManager().getCallbackType(ChannelNoticeListener.class).call(cChannel, cChannelClient, sMessage, sHost);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPrivateAction(final String sMessage, final String sHost) {
-		return getCallbackManager().getCallbackType("OnPrivateAction").call(sMessage, sHost);
+		return getCallbackManager().getCallbackType(PrivateActionListener.class).call(sMessage, sHost);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPrivateCTCP(final String sType, final String sMessage, final String sHost) {
-		return getCallbackManager().getCallbackType("OnPrivateCTCP").call(sType, sMessage, sHost);
+		return getCallbackManager().getCallbackType(PrivateCtcpListener.class).call(sType, sMessage, sHost);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPrivateCTCPReply(final String sType, final String sMessage, final String sHost) {
-		return getCallbackManager().getCallbackType("OnPrivateCTCPReply").call(sType, sMessage, sHost);
+		return getCallbackManager().getCallbackType(PrivateCtcpReplyListener.class).call(sType, sMessage, sHost);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPrivateMessage(final String sMessage, final String sHost) {
-		return getCallbackManager().getCallbackType("OnPrivateMessage").call(sMessage, sHost);
+		return getCallbackManager().getCallbackType(PrivateMessageListener.class).call(sMessage, sHost);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPrivateNotice(final String sMessage, final String sHost) {
-		return getCallbackManager().getCallbackType("OnPrivateNotice").call(sMessage, sHost);
+		return getCallbackManager().getCallbackType(PrivateNoticeListener.class).call(sMessage, sHost);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callUnknownAction(final String sMessage, final String sTarget, final String sHost) {
-		return getCallbackManager().getCallbackType("OnUnknownAction").call(sMessage, sTarget, sHost);
+		return getCallbackManager().getCallbackType(UnknownActionListener.class).call(sMessage, sTarget, sHost);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callUnknownCTCP(final String sType, final String sMessage, final String sTarget, final String sHost) {
-		return getCallbackManager().getCallbackType("OnUnknownCTCP").call(sType, sMessage, sTarget, sHost);
+		return getCallbackManager().getCallbackType(UnknownCtcpListener.class).call(sType, sMessage, sTarget, sHost);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callUnknownCTCPReply(final String sType, final String sMessage, final String sTarget, final String sHost) {
-		return getCallbackManager().getCallbackType("OnUnknownCTCPReply").call(sType, sMessage, sTarget, sHost);
+		return getCallbackManager().getCallbackType(UnknownCtcpReplyListener.class).call(sType, sMessage, sTarget, sHost);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callUnknownMessage(final String sMessage, final String sTarget, final String sHost) {
-		return getCallbackManager().getCallbackType("OnUnknownMessage").call(sMessage, sTarget, sHost);
+		return getCallbackManager().getCallbackType(UnknownMessageListener.class).call(sMessage, sTarget, sHost);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callUnknownNotice(final String sMessage, final String sTarget, final String sHost) {
-		return getCallbackManager().getCallbackType("OnUnknownNotice").call(sMessage, sTarget, sHost);
+		return getCallbackManager().getCallbackType(UnknownNoticeListener.class).call(sMessage, sTarget, sHost);
 	}
 
 	

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.ChannelModeChangeListener;
+import com.dmdirc.parser.interfaces.callbacks.ChannelNonUserModeChangeListener;
+import com.dmdirc.parser.interfaces.callbacks.ChannelSingleModeChangeListener;
+import com.dmdirc.parser.interfaces.callbacks.ChannelUserModeChangeListener;
+import com.dmdirc.parser.interfaces.callbacks.UserModeChangeListener;
+import com.dmdirc.parser.interfaces.callbacks.UserModeDiscoveryListener;
 import com.dmdirc.parser.irc.callbacks.CallbackObject;
 import java.util.Calendar;
 
 		CallbackObject cbNonUser = null;
 
 		if (!sParam.equals("324")) {
-			cbSingle = getCallbackManager().getCallbackType("OnChannelSingleModeChanged");
-			cbNonUser = getCallbackManager().getCallbackType("OnChannelNonUserModeChanged");
+			cbSingle = getCallbackManager().getCallbackType(ChannelSingleModeChangeListener.class);
+			cbNonUser = getCallbackManager().getCallbackType(ChannelNonUserModeChangeListener.class);
 		}
 		
 		iChannel = getChannelInfo(sChannelName);
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelModeChanged(ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sHost, String sModes) {
-		return getCallbackManager().getCallbackType("OnChannelModeChanged").call(cChannel, cChannelClient, sHost, sModes);
+		return getCallbackManager().getCallbackType(ChannelModeChangeListener.class).call(cChannel, cChannelClient, sHost, sModes);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelUserModeChanged(ChannelInfo cChannel, ChannelClientInfo cChangedClient, ChannelClientInfo cSetByClient, String sHost, String sMode) {
-		return getCallbackManager().getCallbackType("OnChannelUserModeChanged").call(cChannel, cChangedClient, cSetByClient, sHost, sMode);
+		return getCallbackManager().getCallbackType(ChannelUserModeChangeListener.class).call(cChannel, cChangedClient, cSetByClient, sHost, sMode);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callUserModeChanged(ClientInfo cClient, String sSetby, String sModes) {
-		return getCallbackManager().getCallbackType("OnUserModeChanged").call(cClient, sSetby, sModes);
+		return getCallbackManager().getCallbackType(UserModeChangeListener.class).call(cClient, sSetby, sModes);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callUserModeDiscovered(ClientInfo cClient, String sModes) {
-		return getCallbackManager().getCallbackType("OnUserModeDiscovered").call(cClient, sModes);
+		return getCallbackManager().getCallbackType(UserModeDiscoveryListener.class).call(cClient, sModes);
 	}	
 	
 	/**

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.ChannelNamesListener;
+
 /**
  * Process a Names reply.
  */
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelGotNames(ChannelInfo cChannel) {
-		return getCallbackManager().getCallbackType("OnChannelGotNames").call(cChannel);
+		return getCallbackManager().getCallbackType(ChannelNamesListener.class).call(cChannel);
 	}
 	
 	/**

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.ChannelNickChangeListener;
+import com.dmdirc.parser.interfaces.callbacks.NickChangeListener;
+
 /**
  * Process a Nick change.
  */
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelNickChanged(ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sOldNick) {
-		return getCallbackManager().getCallbackType("OnChannelNickChanged").call(cChannel, cChannelClient, sOldNick);
+		return getCallbackManager().getCallbackType(ChannelNickChangeListener.class).call(cChannel, cChannelClient, sOldNick);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callNickChanged(ClientInfo cClient, String sOldNick) {
-		return getCallbackManager().getCallbackType("OnNickChanged").call(cClient, sOldNick);
+		return getCallbackManager().getCallbackType(NickChangeListener.class).call(cClient, sOldNick);
 	}
 	
 	/**

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.NickInUseListener;
+
 /**
  * Process a NickInUse message.
  * Parser implements handling of this if Pre-001 and no other handler found,
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callNickInUse(final String nickname) {
-		return getCallbackManager().getCallbackType("OnNickInUse").call(nickname);
+		return getCallbackManager().getCallbackType(NickInUseListener.class).call(nickname);
 	}
 	
 	/**

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.AuthNoticeListener;
+
 /**
  * Process a NoticeAuth message.
  */
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callNoticeAuth(final String data) {
-		return getCallbackManager().getCallbackType("OnNoticeAuth").call(data);
+		return getCallbackManager().getCallbackType(AuthNoticeListener.class).call(data);
 	}
 	
 	/**

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.ChannelPartListener;
+
 /**
  * Process a channel part.
  */
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelPart(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sReason) {
-		return getCallbackManager().getCallbackType("OnChannelPart").call(cChannel, cChannelClient, sReason);
+		return getCallbackManager().getCallbackType(ChannelPartListener.class).call(cChannel, cChannelClient, sReason);
 	}
 	
 	/**

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.ChannelQuitListener;
+import com.dmdirc.parser.interfaces.callbacks.QuitListener;
 import java.util.ArrayList;
 
 /**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelQuit(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sReason) {
-		return getCallbackManager().getCallbackType("OnChannelQuit").call(cChannel, cChannelClient, sReason);
+		return getCallbackManager().getCallbackType(ChannelQuitListener.class).call(cChannel, cChannelClient, sReason);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callQuit(final ClientInfo cClient, final String sReason) {
-		return getCallbackManager().getCallbackType("OnQuit").call(cClient, sReason);
+		return getCallbackManager().getCallbackType(QuitListener.class).call(cClient, sReason);
 	}
 	
 	/**

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.ChannelTopicListener;
+
 /**
  * Process a topic change.
  */
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelTopic(final ChannelInfo cChannel, final boolean bIsJoinTopic) {
-		return getCallbackManager().getCallbackType("OnChannelTopic").call(cChannel, bIsJoinTopic);
+		return getCallbackManager().getCallbackType(ChannelTopicListener.class).call(cChannel, bIsJoinTopic);
 	}
 	
 	/**

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.WallDesyncListener;
+import com.dmdirc.parser.interfaces.callbacks.WallopListener;
+import com.dmdirc.parser.interfaces.callbacks.WalluserListener;
+
 /**
  * Process a WALLOPS Message.
  */
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callWallop(final String message, final String host) {
-		return getCallbackManager().getCallbackType("OnWallop").call(message, host);
+		return getCallbackManager().getCallbackType(WallopListener.class).call(message, host);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callWalluser(final String message, final String host) {
-		return getCallbackManager().getCallbackType("OnWalluser").call(message, host);
+		return getCallbackManager().getCallbackType(WalluserListener.class).call(message, host);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callWallDesync(final String message, final String host) {
-		return getCallbackManager().getCallbackType("OnWallDesync").call(message, host);
+		return getCallbackManager().getCallbackType(WallDesyncListener.class).call(message, host);
 	}
 	
 	

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.AwayStateListener;
+import com.dmdirc.parser.interfaces.callbacks.ChannelOtherAwayStateListener;
+import com.dmdirc.parser.interfaces.callbacks.OtherAwayStateListener;
+
 /**
  * Process a /who reply.
  */
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callAwayState(boolean currentState, String reason) {
-		return getCallbackManager().getCallbackType("OnAwayState").call(currentState, reason);
+		return getCallbackManager().getCallbackType(AwayStateListener.class).call(currentState, reason);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callAwayStateOther(final ClientInfo client, final boolean state) {
-		return getCallbackManager().getCallbackType("OnAwayStateOther").call(client, state);
+		return getCallbackManager().getCallbackType(OtherAwayStateListener.class).call(client, state);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelAwayStateOther(final ChannelInfo channel, final ChannelClientInfo channelClient, final boolean state) {
-		return getCallbackManager().getCallbackType("OnChannelAwayStateOther").call(channel, channelClient, state);
+		return getCallbackManager().getCallbackType(ChannelOtherAwayStateListener.class).call(channel, channelClient, state);
 	}
 	
 	/**

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

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.interfaces.callbacks.NumericListener;
 import java.util.Hashtable;
 
 /**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callNumeric(final int numeric, final String[] token) {
-		return myParser.getCallbackManager().getCallbackType("OnNumeric").call(numeric, token);
+		return myParser.getCallbackManager().getCallbackType(NumericListener.class).call(numeric, token);
 	}
 
 }

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

  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-
 package com.dmdirc.parser.irc.callbacks;
 
 import com.dmdirc.parser.interfaces.callbacks.*;
 public final class CallbackManager {
 
     private static final Class[] CLASSES = {
-        AwayStateListener.class, OtherAwayStateListener.class, ChannelOtherAwayStateListener.class,
-        ChannelActionListener.class, ChannelCtcpListener.class, ChannelCtcpReplyListener.class,
-        ChannelListModeListener.class, ChannelNamesListener.class, ChannelJoinListener.class,
-        ChannelKickListener.class, ChannelMessageListener.class, ChannelModeChangeListener.class,
+        AwayStateListener.class, OtherAwayStateListener.class,
+        ChannelOtherAwayStateListener.class, ChannelActionListener.class,
+        ChannelCtcpListener.class, ChannelCtcpReplyListener.class,
+        ChannelListModeListener.class, ChannelNamesListener.class,
+        ChannelJoinListener.class, ChannelKickListener.class,
+        ChannelMessageListener.class, ChannelModeChangeListener.class,
         ChannelNickChangeListener.class, ChannelNonUserModeChangeListener.class,
 	ChannelModeMessage.class, ChannelModeNotice.class,
         ChannelNoticeListener.class, ChannelPartListener.class, ChannelQuitListener.class,
         WallDesyncListener.class, WallopListener.class, WalluserListener.class,
     };
 
-	/** Reference to the parser object that owns this CallbackManager. */
-	IRCParser myParser;
-	
-	/** Hashtable used to store the different types of callback known. */
-	private final Map<String, CallbackObject> callbackHash = new Hashtable<String, CallbackObject>();
-	
-	/**
-	 * Constructor to create a CallbackManager.
-	 *
-	 * @param parser IRCParser that owns this callback manager.
-	 */
-	public CallbackManager(final IRCParser parser) {
-		myParser = parser;
-		
+    /** Reference to the parser object that owns this CallbackManager. */
+    IRCParser myParser;
+    /** Hashtable used to store the different types of callback known. */
+    private final Map<Class<? extends CallbackInterface>, CallbackObject> callbackHash
+            = new Hashtable<Class<? extends CallbackInterface>, CallbackObject>();
+
+    /**
+     * Constructor to create a CallbackManager.
+     *
+     * @param parser IRCParser that owns this callback manager.
+     */
+    public CallbackManager(final IRCParser parser) {
+        myParser = parser;
+
         for (Class<?> type : CLASSES) {
             if (type.isAnnotationPresent(SpecificCallback.class)) {
                 addCallbackType(new CallbackObjectSpecific(myParser, this,
                         type.asSubclass(CallbackInterface.class)));
             }
         }
-	}
-
-	/**
-	 * Add new callback type.
-	 *
-	 * @param callback CallbackObject subclass for the callback.
-	 * @return if adding succeeded or not.
-	 */
-	public boolean addCallbackType(final CallbackObject callback) {
-		if (!callbackHash.containsKey(callback.getLowerName())) {
-			callbackHash.put(callback.getLowerName(), callback);
-			return true;
-		}
-		return false;
-	}
-	
-	/**
-	 * Remove a callback type.
-	 *
-	 * @param callback CallbackObject subclass to remove.
-	 * @return if removal succeeded or not.
-	 */
-	public boolean delCallbackType(final CallbackObject callback) {
-		if (callbackHash.containsKey(callback.getLowerName())) {
-			callbackHash.remove(callback.getLowerName());
-			return true;
-		}
-		return false;
-	}
-	
-	/**
-	 * Get reference to callback object.
-	 *
-	 * @param callbackName Name of callback object.
-	 * @return CallbackObject returns the callback object for this type
-	 */
-	public CallbackObject getCallbackType(final String callbackName) {
-		if (!callbackHash.containsKey(callbackName.toLowerCase())) {
-			throw new CallbackNotFoundException("Callback not found: " + callbackName);
-		}
-		
-		return callbackHash.get(callbackName.toLowerCase());
-	}
-	
-	/**
-	 * Remove all callbacks associated with a specific object.
-	 *
-	 * @param o instance of ICallbackInterface to remove.
-	 */
-	public void delAllCallback(final CallbackInterface o) {
-		for (CallbackObject cb : callbackHash.values()) {
-			if (cb != null) { cb.del(o); }
-		}
-	}
-	
-	/**
-	 * Add all callbacks.
-	 *
-	 * @param o instance of ICallbackInterface to add.
-	 */
-	public void addAllCallback(final CallbackInterface o) {
-		for (CallbackObject cb : callbackHash.values()) {
-			if (cb != null) { cb.add(o); }
-		}
-	}
-	
-	/**
-	 * Add a callback.
- 	 * This method will throw a CallbackNotFoundException if the callback does not exist.
-	 *
-	 * @param callbackName Name of callback object.
-	 * @param o instance of ICallbackInterface to add.
-	 * @throws CallbackNotFoundException If callback is not found.
-	 * @throws NullPointerException If 'o' is null
-	 */
-	public void addCallback(final String callbackName, final CallbackInterface o) throws CallbackNotFoundException {
-		if (o == null) {
-			throw new NullPointerException("CallbackInterface is null");
-		}
-		
-		final CallbackObject cb = getCallbackType(callbackName);
-		
-		if (cb != null) { cb.add(o); }
-	}
-	
-	/**
-	 * Add a callback with a specific target.
- 	 * This method will throw a CallbackNotFoundException if the callback does not exist.
-	 *
-	 * @param callbackName Name of callback object.
-	 * @param o instance of ICallbackInterface to add.
-	 * @param target Parameter to specify that a callback should only fire for specific things
-	 * @throws CallbackNotFoundException If callback is not found.
-	 * @throws NullPointerException If 'o' is null
-	 */
-	public void addCallback(final String callbackName, final CallbackInterface o, final String target) throws CallbackNotFoundException {
-		if (o == null) { throw new NullPointerException("CallbackInterface is null"); }
-		((CallbackObjectSpecific) getCallbackType(callbackName)).add(o,target);
-	}
-	
-	/**
-	 * Add a callback without an exception.
-	 * This should be used if a callback is not essential for execution (ie the DebugOut callback)
-	 *
-	 * @param callbackName Name of callback object.
-	 * @param o instance of ICallbackInterface to add.
-	 * @return true/false if the callback was added or not.
-	 */
-	public boolean addNonCriticalCallback(final String callbackName, final CallbackInterface o)  {
-		try {
-			addCallback(callbackName, o);
-			return true;
-		} catch (CallbackNotFoundException e) { return false; }
-	}
-	
-	/**
-	 * Add a callback with a specific target.
-	 * This should be used if a callback is not essential for execution
-	 *
-	 * @param callbackName Name of callback object.
-	 * @param o instance of ICallbackInterface to add.
-	 * @param target Parameter to specify that a callback should only fire for specific things
-	 * @return true/false if the callback was added or not.
-	 */
-	public boolean addNonCriticalCallback(final String callbackName, final CallbackInterface o, final String target) {
-		try {
-			addCallback(callbackName, o, target);
-			return true;
-		} catch (CallbackNotFoundException e) { return false;	}
-	}
-	
-	
-	/**
-	 * Remove a callback.
-	 *
-	 * @param callbackName Name of callback object.
-	 * @param o instance of ICallbackInterface to remove.
-	 */
-	public void delCallback(final String callbackName, final CallbackInterface o) {
-		getCallbackType(callbackName).del(o);
-	}
+    }
+
+    /**
+     * Add new callback type.
+     *
+     * @param callback CallbackObject subclass for the callback.
+     * @return if adding succeeded or not.
+     */
+    public boolean addCallbackType(final CallbackObject callback) {
+        if (!callbackHash.containsKey(callback.getType())) {
+            callbackHash.put(callback.getType(), callback);
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Remove a callback type.
+     *
+     * @param callback CallbackObject subclass to remove.
+     * @return if removal succeeded or not.
+     */
+    public boolean delCallbackType(final CallbackObject callback) {
+        if (callbackHash.containsKey(callback.getType())) {
+            callbackHash.remove(callback.getType());
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Get reference to callback object.
+     *
+     * @param callback Name of type of callback object.
+     * @return CallbackObject returns the callback object for this type
+     */
+    public CallbackObject getCallbackType(final Class<? extends CallbackInterface> callback) {
+        if (!callbackHash.containsKey(callback)) {
+            throw new CallbackNotFoundException("Callback not found: " + callback.getName());
+        }
+
+        return callbackHash.get(callback);
+    }
+
+    /**
+     * Remove all callbacks associated with a specific object.
+     *
+     * @param o instance of ICallbackInterface to remove.
+     */
+    public void delAllCallback(final CallbackInterface o) {
+        for (CallbackObject cb : callbackHash.values()) {
+            if (cb != null) {
+                cb.del(o);
+            }
+        }
+    }
+
+    /**
+     * Add all callbacks.
+     *
+     * @param o instance of ICallbackInterface to add.
+     */
+    public void addAllCallback(final CallbackInterface o) {
+        for (CallbackObject cb : callbackHash.values()) {
+            if (cb != null) {
+                cb.add(o);
+            }
+        }
+    }
+
+    /**
+     * Add a callback.
+     * This method will throw a CallbackNotFoundException if the callback does not exist.
+     *
+     * @param <T> The type of callback
+     * @param callback Type of callback object
+     * @param o instance of ICallbackInterface to add.
+     * @throws CallbackNotFoundException If callback is not found.
+     * @throws NullPointerException If 'o' is null
+     */
+    public <T extends CallbackInterface> void addCallback(
+            final Class<T> callback, final T o) throws CallbackNotFoundException {
+        if (o == null) {
+            throw new NullPointerException("CallbackInterface is null");
+        }
+
+        final CallbackObject cb = getCallbackType(callback);
+
+        if (cb != null) {
+            cb.add(o);
+        }
+    }
+
+    /**
+     * Add a callback with a specific target.
+     * This method will throw a CallbackNotFoundException if the callback does not exist.
+     *
+     * @param <T> The type of callback
+     * @param callback Type of callback object.
+     * @param o instance of ICallbackInterface to add.
+     * @param target Parameter to specify that a callback should only fire for specific things
+     * @throws CallbackNotFoundException If callback is not found.
+     * @throws NullPointerException If 'o' is null
+     */
+    public <T extends CallbackInterface> void addCallback(
+            final Class<T> callback,
+            final T o, final String target) throws CallbackNotFoundException {
+        if (o == null) {
+            throw new NullPointerException("CallbackInterface is null");
+        }
+        
+        ((CallbackObjectSpecific) getCallbackType(callback)).add(o, target);
+    }
+
+    /**
+     * Add a callback without an exception.
+     * This should be used if a callback is not essential for execution (ie the DebugOut callback)
+     *
+     * @param <T> The type of callback object
+     * @param callback Type of callback object.
+     * @param o instance of ICallbackInterface to add.
+     * @return true/false if the callback was added or not.
+     */
+    public <T extends CallbackInterface> boolean addNonCriticalCallback(
+            final Class<T> callback, final T o) {
+        try {
+            addCallback(callback, o);
+            return true;
+        } catch (CallbackNotFoundException e) {
+            return false;
+        }
+    }
+
+    /**
+     * Add a callback with a specific target.
+     * This should be used if a callback is not essential for execution
+     *
+     * @param <T> The type of callback
+     * @param callback Type of callback object.
+     * @param o instance of ICallbackInterface to add.
+     * @param target Parameter to specify that a callback should only fire for specific things
+     * @return true/false if the callback was added or not.
+     */
+    public <T extends CallbackInterface> boolean addNonCriticalCallback(
+            final Class<T> callback, final T o, final String target) {
+        try {
+            addCallback(callback, o, target);
+            return true;
+        } catch (CallbackNotFoundException e) {
+            return false;
+        }
+    }
 
+    /**
+     * Remove a callback.
+     *
+     * @param callback Type of callback object.
+     * @param o instance of ICallbackInterface to remove.
+     */
+    public void delCallback(final Class<? extends CallbackInterface> callback,
+            final CallbackInterface o) {
+        getCallbackType(callback).del(o);
+    }
 }

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

 import com.dmdirc.parser.irc.ParserError;
 import com.dmdirc.parser.interfaces.callbacks.CallbackInterface;
 
+import com.dmdirc.parser.interfaces.callbacks.ErrorInfoListener;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 	 * @return true if error call succeeded, false otherwise
 	 */
 	protected final boolean callErrorInfo(final ParserError errorInfo) {
-		return myManager.getCallbackType("OnErrorInfo").call(errorInfo);
+		return myManager.getCallbackType(ErrorInfoListener.class).call(errorInfo);
 	}
 	
 	/**
 	 * @param eMethod Object to remove callback to.
 	 */
 	public void del(final CallbackInterface eMethod) { delCallback(eMethod); }
-	
-	/**
-	 * Get the name for this callback.
-	 *
-	 * @return Name of callback
-	 */
-	public String getName() {
-		return "On" + type.getSimpleName().substring(1); // Trim the 'I'
-	}
-	
-	/**
-	 * Get the name for this callback in lowercase.
-	 *
-	 * @return Name of callback, in lowercase
-	 */
-	public final String getLowerName() { return this.getName().toLowerCase(); }
 
+    /**
+     * Retrieves the type of callback that this callback object is for.
+     *
+     * @return This object's type
+     * @since 0.6.3m2
+     */
+    public Class<? extends CallbackInterface> getType() {
+        return type;
+    }
+	
     /**
      * Actually calls this callback. The specified arguments must match those
      * specified in the callback's interface, or an error will be raised.

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

 import com.dmdirc.harness.parser.TestIPost005;
 import com.dmdirc.harness.parser.TestIPrivateMessage;
 import com.dmdirc.harness.parser.TestIPrivateAction;
+import com.dmdirc.parser.interfaces.callbacks.AuthNoticeListener;
 import com.dmdirc.parser.irc.callbacks.CallbackNotFoundException;
 import com.dmdirc.parser.interfaces.callbacks.AwayStateListener;
 import com.dmdirc.parser.interfaces.callbacks.ChannelKickListener;
 
+import com.dmdirc.parser.interfaces.callbacks.ConnectErrorListener;
 import com.dmdirc.parser.interfaces.callbacks.ErrorInfoListener;
+import com.dmdirc.parser.interfaces.callbacks.NumericListener;
+import com.dmdirc.parser.interfaces.callbacks.Post005Listener;
+import com.dmdirc.parser.interfaces.callbacks.PrivateActionListener;
+import com.dmdirc.parser.interfaces.callbacks.PrivateCtcpListener;
+import com.dmdirc.parser.interfaces.callbacks.PrivateMessageListener;
+import com.dmdirc.parser.interfaces.callbacks.ServerErrorListener;
 import java.util.Arrays;
 import java.util.List;
 
 
         try {
             final IRCParser myParser = new IRCParser();
-            myParser.getCallbackManager().addCallback("non-existant", mock(AwayStateListener.class));
+            myParser.getCallbackManager().addCallback(null, mock(AwayStateListener.class));
         } catch (CallbackNotFoundException ex) {
             res = true;
         }
         final ErrorInfoListener error = mock(ErrorInfoListener.class);
 
         final TestParser myParser = new TestParser();
-        myParser.getCallbackManager().addCallback("onErrorInfo", error);
+        myParser.getCallbackManager().addCallback(ErrorInfoListener.class, error);
         myParser.injectConnectionStrings();
         myParser.nick = "nick2";
         myParser.injectConnectionStrings();
         si.setUseSocks(true);
         
         final IRCParser myParser = new IRCParser(si);
-        myParser.getCallbackManager().addCallback("onConnectError", tice);
+        myParser.getCallbackManager().addCallback(ConnectErrorListener.class, tice);
         myParser.setBindIP("0.0.0.0");
         myParser.run();
         
         final TestIServerError test = new TestIServerError();
 
         final TestParser parser = new TestParser();
-        parser.getCallbackManager().addCallback("onServerError", test);
+        parser.getCallbackManager().addCallback(ServerErrorListener.class, test);
         parser.injectLine("ERROR :You smell of cheese");
 
         assertNotNull(test.message);
     public void testAuthNotices() throws CallbackNotFoundException {
         final TestINoticeAuth test = new TestINoticeAuth();
         final TestParser parser = new TestParser();
-        parser.getCallbackManager().addCallback("onNoticeAuth", test);
+        parser.getCallbackManager().addCallback(AuthNoticeListener.class, test);
         parser.sendConnectionStrings();
         parser.injectLine("NOTICE AUTH :Random auth notice?");
 
     public void testPre001NickChange() throws CallbackNotFoundException {
         final TestINoticeAuth test = new TestINoticeAuth();
         final TestParser parser = new TestParser();
-        parser.getCallbackManager().addCallback("onNoticeAuth", test);
+        parser.getCallbackManager().addCallback(AuthNoticeListener.class, test);
         parser.sendConnectionStrings();
         parser.injectLine(":chris!@ NICK :user2");
 
     public void testNumeric() throws CallbackNotFoundException {
         final TestINumeric test = new TestINumeric();
         final TestParser parser = new TestParser();
-        parser.getCallbackManager().addCallback("onNumeric", test);
+        parser.getCallbackManager().addCallback(NumericListener.class, test);
 
         parser.injectLine(":server 001 nick :Hi there, nick");
 
     public void testPost005() throws CallbackNotFoundException {
         final TestIPost005 test = new TestIPost005();
         final TestParser parser = new TestParser();
-        parser.getCallbackManager().addCallback("onPost005", test);
+        parser.getCallbackManager().addCallback(Post005Listener.class, test);
 
         final String[] strings = {
             "NOTICE AUTH :Blah, blah",
 
         parser.injectConnectionStrings();
 
-        parser.getCallbackManager().addCallback("onPrivateMessage", ipmtest);
-        parser.getCallbackManager().addCallback("onPrivateAction", ipatest);
-        parser.getCallbackManager().addCallback("onPrivateCTCP", ipctest);
+        parser.getCallbackManager().addCallback(PrivateMessageListener.class, ipmtest);
+        parser.getCallbackManager().addCallback(PrivateActionListener.class, ipatest);
+        parser.getCallbackManager().addCallback(PrivateCtcpListener.class, ipctest);
 
         parser.injectLine(":a!b@c PRIVMSG nick :Hello!");
         assertNotNull(ipmtest.host);
         parser.injectConnectionStrings();
 
         parser.injectLine(":nick JOIN #D");
-        parser.getCallbackManager().addCallback("onChannelKick", ick, "#D");
+        parser.getCallbackManager().addCallback(ChannelKickListener.class, ick, "#D");
         parser.injectLine(":bar!me@moo KICK #D nick :Bye!");
 
         verify(ick).onChannelKick(same(parser), (ChannelInfo) anyObject(),
     public void testIllegalPort1() {
         final TestParser tp = new TestParser(new MyInfo(), new ServerInfo("127.0.0.1", 0, ""));
         final TestIConnectError tiei = new TestIConnectError();
-        tp.getCallbackManager().addCallback("OnConnectError", tiei);
+        tp.getCallbackManager().addCallback(ConnectErrorListener.class, tiei);
         tp.runSuper();
         assertTrue(tiei.error);
     }
     public void testIllegalPort2() {
         final TestParser tp = new TestParser(new MyInfo(), new ServerInfo("127.0.0.1", 1, ""));
         final TestIConnectError tiei = new TestIConnectError();
-        tp.getCallbackManager().addCallback("OnConnectError", tiei);
+        tp.getCallbackManager().addCallback(ConnectErrorListener.class, tiei);
         tp.runSuper();
         assertTrue(tiei.error);
     }    
     public void testIllegalPort3() {
         final TestParser tp = new TestParser(new MyInfo(), new ServerInfo("127.0.0.1", 65570, ""));
         final TestIConnectError tiei = new TestIConnectError();
-        tp.getCallbackManager().addCallback("OnConnectError", tiei);
+        tp.getCallbackManager().addCallback(ConnectErrorListener.class, tiei);
         tp.runSuper();
         assertTrue(tiei.error);
     }

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

 
 import com.dmdirc.harness.parser.TestIErrorInfo;
 import com.dmdirc.harness.parser.TestParser;
+import com.dmdirc.parser.interfaces.callbacks.ErrorInfoListener;
 import org.junit.Test;
 import static org.junit.Assert.*;
 
         final TestParser tp = doCaseMappingTest("rfc1459", 4);
         final TestIErrorInfo tiei = new TestIErrorInfo();
         
-        tp.getCallbackManager().addCallback("OnErrorInfo", tiei);
+        tp.getCallbackManager().addCallback(ErrorInfoListener.class, tiei);
         
         tp.injectLine(":server 005 nick CASEMAPPING=unknown :are supported by this server");
         

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

 import com.dmdirc.parser.irc.callbacks.CallbackNotFoundException;
 import com.dmdirc.parser.interfaces.callbacks.ChannelJoinListener;
 
+import com.dmdirc.parser.interfaces.callbacks.ChannelSelfJoinListener;
 import org.junit.Test;
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
         final TestIChannelSelfJoin test = new TestIChannelSelfJoin();
 
         parser.injectConnectionStrings();
-        parser.getCallbackManager().addCallback("onChannelSelfJoin", test);
+        parser.getCallbackManager().addCallback(ChannelSelfJoinListener.class, test);
         parser.injectLine(":nick JOIN #DMDirc_testing");
 
         assertNotNull(test.channel);
         final ChannelJoinListener test = mock(ChannelJoinListener.class);
 
         parser.injectConnectionStrings();
-        parser.getCallbackManager().addCallback("onChannelJoin", test);
+        parser.getCallbackManager().addCallback(ChannelJoinListener.class, test);
         
         parser.injectLine(":nick JOIN #DMDirc_testing");
         parser.injectLine(":foo!bar@baz JOIN #DMDirc_testing");

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

         final TestParser parser = new TestParser();
         final TestIErrorInfo test = new TestIErrorInfo();
         parser.injectConnectionStrings();
-        parser.getCallbackManager().addCallback("OnErrorInfo", test);
+        parser.getCallbackManager().addCallback(ErrorInfoListener.class, test);
         
         parser.injectLine(":server 366 nick #nonexistant :End of /NAMES list.");
         

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

 import com.dmdirc.harness.parser.TestParser;
 import com.dmdirc.harness.parser.TestIErrorInfo;
 import com.dmdirc.harness.parser.TestINickChanged;
+import com.dmdirc.parser.interfaces.callbacks.ErrorInfoListener;
+import com.dmdirc.parser.interfaces.callbacks.NickChangeListener;
 import com.dmdirc.parser.irc.callbacks.CallbackNotFoundException;
 import org.junit.Test;
 import static org.junit.Assert.*;
         final TestParser parser = new TestParser();
         final TestINickChanged tinc = new TestINickChanged();
 
-        parser.getCallbackManager().addCallback("OnNickChanged", tinc);
+        parser.getCallbackManager().addCallback(NickChangeListener.class, tinc);
         
         parser.injectConnectionStrings();
         parser.injectLine(":nick JOIN #DMDirc_testing");
         final TestParser parser = new TestParser();
         final TestIErrorInfo info = new TestIErrorInfo();
         
-        parser.getCallbackManager().addCallback("OnErrorInfo", info);
+        parser.getCallbackManager().addCallback(ErrorInfoListener.class, info);
         parser.injectConnectionStrings();
         parser.injectLine(":nick JOIN #DMDirc_testing");
         parser.injectLine(":server 353 nick = #DMDirc_testing :@nick +luser @+nick2 nick3");
         final TestParser parser = new TestParser();
         final TestINickChanged tinc = new TestINickChanged();
         
-        parser.getCallbackManager().addCallback("OnNickChanged", tinc);
+        parser.getCallbackManager().addCallback(NickChangeListener.class, tinc);
         
         parser.injectConnectionStrings();
         parser.injectLine(":random!lu@ser NICK rand");

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

 import com.dmdirc.parser.irc.callbacks.CallbackNotFoundException;
 
 import com.dmdirc.parser.interfaces.callbacks.ChannelPartListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelQuitListener;
-import com.dmdirc.parser.interfaces.callbacks.QuitListener;
 import org.junit.Test;
 import static org.junit.Assert.*;
 
         parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list.");
         
         final TestIChannelPart test = new TestIChannelPart();
-        parser.getCallbackManager().addCallback("OnChannelPart", test);
+        parser.getCallbackManager().addCallback(ChannelPartListener.class, test);
         
         assertEquals(2, parser.getChannelInfo("#DMDirc_testing").getChannelClients().size());
         
         parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list.");
         
         final TestIChannelPart test = new TestIChannelPart();
-        parser.getCallbackManager().addCallback("OnChannelPart", test);
+        parser.getCallbackManager().addCallback(ChannelPartListener.class, test);
         
         assertEquals(2, parser.getChannelInfo("#DMDirc_testing").getChannelClients().size());
         

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

 
 import com.dmdirc.harness.parser.TestParser;
 import com.dmdirc.harness.parser.TestIQuit;
-import com.dmdirc.parser.irc.callbacks.CallbackNotFoundException;
-
 import com.dmdirc.parser.interfaces.callbacks.ChannelQuitListener;
 import com.dmdirc.parser.interfaces.callbacks.QuitListener;
+import com.dmdirc.parser.irc.callbacks.CallbackNotFoundException;
+
 import org.junit.Test;
 import static org.junit.Assert.*;
 
         parser.injectLine(":server 366 nick #DMDirc_testing2 :End of /NAMES list.");        
         
         final TestIQuit test = new TestIQuit();
-        parser.getCallbackManager().addCallback("OnChannelQuit", test);
+        parser.getCallbackManager().addCallback(ChannelQuitListener.class, test);
         
         assertEquals(2, parser.getChannelInfo("#DMDirc_testing").getChannelClients().size());
         
         parser.injectLine(":server 366 nick #DMDirc_testing2 :End of /NAMES list.");
         
         final TestIQuit test = new TestIQuit();
-        parser.getCallbackManager().addCallback("OnQuit", test);
+        parser.getCallbackManager().addCallback(QuitListener.class, test);
         
         assertEquals(2, parser.getChannelInfo("#DMDirc_testing").getChannelClients().size());
         
         parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list.");
         
         final TestIQuit test = new TestIQuit();
-        parser.getCallbackManager().addCallback("OnQuit", test);
+        parser.getCallbackManager().addCallback(QuitListener.class, test);
         
         assertEquals(2, parser.getChannelInfo("#DMDirc_testing").getChannelClients().size());
         

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

         final TestParser parser = new TestParser();
         final TestIChannelTopic test = new TestIChannelTopic();
         parser.injectConnectionStrings();
-        parser.getCallbackManager().addCallback("OnChannelTopic", test);
+        parser.getCallbackManager().addCallback(ChannelTopicListener.class, test);
         
         parser.injectLine(":nick JOIN #DMDirc_testing");
         parser.injectLine(":server 332 nick #DMDirc_testing :This be a topic");
         parser.injectLine(":server 332 nick #DMDirc_testing :This be a topic");
         parser.injectLine(":server 333 nick #DMDirc_testing Q 1207350306");
         
-        parser.getCallbackManager().addCallback("OnChannelTopic", test);
+        parser.getCallbackManager().addCallback(ChannelTopicListener.class, test);
         
         parser.injectLine(":foobar TOPIC #DMDirc_testing :New topic here");
         

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

         final TestParser parser = new TestParser();
         final AwayStateListener test = mock(AwayStateListener.class);
         parser.injectConnectionStrings();
-        parser.getCallbackManager().addCallback("OnAwayState", test);
+        parser.getCallbackManager().addCallback(AwayStateListener.class, test);
 
         parser.injectLine(":nick JOIN #DMDirc_testing");