Initial work on XMPP parser and parser base abstraction

Depends-On: I3bfbb811a5b5055d8dbe511a0390c3413d133292
Depends-On: I694d18a653ca8c3e3cad9d0e766e2fd207e615e9
Change-Id: I4ff484e8a2597017283eea557170c4aeb2029faa
Reviewed-on: http://gerrit.dmdirc.com/1852
Automatic-Compile: DMDirc Local Commits <dmdirc@googlemail.com>
Reviewed-by: Greg Holmes <greg@dmdirc.com>

src/com/dmdirc/addons/parser_twitter/Twitter.java

@@ -62,7 +62,6 @@ import com.dmdirc.parser.interfaces.callbacks.MotdStartListener;
 import com.dmdirc.parser.interfaces.callbacks.NetworkDetectedListener;
 import com.dmdirc.parser.interfaces.callbacks.NickChangeListener;
 import com.dmdirc.parser.interfaces.callbacks.NumericListener;
-import com.dmdirc.parser.interfaces.callbacks.Post005Listener;
 import com.dmdirc.parser.interfaces.callbacks.PrivateMessageListener;
 import com.dmdirc.parser.interfaces.callbacks.PrivateNoticeListener;
 import com.dmdirc.parser.interfaces.callbacks.ServerReadyListener;
@@ -94,6 +93,16 @@ public class Twitter implements Parser, TwitterErrorHandler, TwitterRawHandler,
     private static final long PRUNE_COUNT = 20;
     /** Maximum age of items to leave in the status cache when pruning. */
     private static final long PRUNE_TIME = 3600 * 1000;
+    
+    /** A map of this parser's implementations of common interfaces. */
+    protected static final Map<Class<?>, Class<?>> IMPL_MAP = new HashMap<Class<?>, Class<?>>();
+
+    static {
+        IMPL_MAP.put(ChannelClientInfo.class, TwitterChannelClientInfo.class);
+        IMPL_MAP.put(ChannelInfo.class, TwitterChannelInfo.class);
+        IMPL_MAP.put(ClientInfo.class, TwitterClientInfo.class);
+        IMPL_MAP.put(LocalClientInfo.class, TwitterClientInfo.class);
+    }
 
     /** Are we connected? */
     private boolean connected = false;
@@ -122,7 +131,7 @@ public class Twitter implements Parser, TwitterErrorHandler, TwitterRawHandler,
     private final String myPassword;
 
     /** Callback Manager for Twitter. */
-    private final CallbackManager<Twitter> myCallbackManager = new TwitterCallbackManager(this);
+    private final CallbackManager myCallbackManager = new CallbackManager(this, IMPL_MAP);
 
     /** String Convertor. */
     private final DefaultStringConverter myStringConverter = new DefaultStringConverter();
@@ -601,7 +610,7 @@ public class Twitter implements Parser, TwitterErrorHandler, TwitterRawHandler,
 
     /** {@inheritDoc} */
     @Override
-    public CallbackManager<? extends Parser> getCallbackManager() {
+    public CallbackManager getCallbackManager() {
         return myCallbackManager;
     }
 
@@ -1058,7 +1067,6 @@ public class Twitter implements Parser, TwitterErrorHandler, TwitterRawHandler,
         getCallbackManager().getCallbackType(ServerReadyListener.class).call();
         // Fake 005
         getCallbackManager().getCallbackType(NetworkDetectedListener.class).call(getNetworkName(), getServerSoftware(), getServerSoftwareType());
-        getCallbackManager().getCallbackType(Post005Listener.class).call();
         // Fake MOTD
         getCallbackManager().getCallbackType(AuthNoticeListener.class).call("Welcome to " + myServerName + ".");
         getCallbackManager().getCallbackType(MotdStartListener.class).call("- " + myServerName + " Message of the Day -");

src/com/dmdirc/addons/parser_twitter/TwitterCallbackObject.java

@@ -1,71 +0,0 @@
-/*
- * 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.addons.parser_twitter;
-
-import com.dmdirc.parser.common.CallbackManager;
-import com.dmdirc.parser.common.CallbackObject;
-import com.dmdirc.parser.interfaces.ChannelClientInfo;
-import com.dmdirc.parser.interfaces.ChannelInfo;
-import com.dmdirc.parser.interfaces.ClientInfo;
-import com.dmdirc.parser.interfaces.LocalClientInfo;
-import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.interfaces.callbacks.CallbackInterface;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * A callback object for the Twitter parser.
- *
- * @since 0.6.3m2
- * @author chris
- */
-public class TwitterCallbackObject extends CallbackObject {
-
-    /** A map of interfaces to the classes which should be instansiated for them. */
-    protected static final Map<Class<?>, Class<?>> IMPL_MAP = new HashMap<Class<?>, Class<?>>();
-
-    static {
-        IMPL_MAP.put(ChannelClientInfo.class, TwitterChannelClientInfo.class);
-        IMPL_MAP.put(ChannelInfo.class, TwitterChannelInfo.class);
-        IMPL_MAP.put(ClientInfo.class, TwitterClientInfo.class);
-        IMPL_MAP.put(LocalClientInfo.class, TwitterClientInfo.class);
-    }
-
-    /**
-     * Create a new TwitterCallbackObject.
-     *
-     * @param parser Parser that owns this object.
-     * @param manager Callback Manager that owns this object.
-     * @param type Type of callback.
-     */
-    public TwitterCallbackObject(final Parser parser, final CallbackManager<?> manager, final Class<? extends CallbackInterface> type) {
-        super(parser, manager, type);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    protected Class<?> getImplementation(final Class<?> type) {
-        return IMPL_MAP.containsKey(type) ? IMPL_MAP.get(type) : type;
-    }
-
-}

src/com/dmdirc/addons/parser_twitter/TwitterCallbackObjectSpecific.java

@@ -1,78 +0,0 @@
-/*
- * 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.addons.parser_twitter;
-
-import com.dmdirc.parser.common.CallbackManager;
-import com.dmdirc.parser.common.CallbackObjectSpecific;
-import com.dmdirc.parser.interfaces.ChannelClientInfo;
-import com.dmdirc.parser.interfaces.ChannelInfo;
-import com.dmdirc.parser.interfaces.ClientInfo;
-import com.dmdirc.parser.interfaces.LocalClientInfo;
-import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.interfaces.callbacks.CallbackInterface;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * A specific callback object for use with the Twitter Parser
- *
- * @since 0.6.3m2
- * @author chris
- */
-public class TwitterCallbackObjectSpecific extends CallbackObjectSpecific {
-
-    /** A map of interfaces to the classes which should be instansiated for them. */
-    protected static final Map<Class<?>, Class<?>> IMPL_MAP = new HashMap<Class<?>, Class<?>>();
-
-    static {
-        IMPL_MAP.put(ChannelClientInfo.class, TwitterChannelClientInfo.class);
-        IMPL_MAP.put(ChannelInfo.class, TwitterChannelInfo.class);
-        IMPL_MAP.put(ClientInfo.class, TwitterClientInfo.class);
-        IMPL_MAP.put(LocalClientInfo.class, TwitterClientInfo.class);
-    }
-
-    /**
-     * Create a new TwitterCallbackObjectSpecific.
-     * This is a TwitterCallbackObject that has a specific target.
-     *
-     * @param parser Parser that owns this object.
-     * @param manager Callback Manager that owns this object.
-     * @param type Type of callback.
-     */
-    public TwitterCallbackObjectSpecific(final Parser parser, final CallbackManager<?> manager, final Class<? extends CallbackInterface> type) {
-        super(parser, manager, type);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    protected String translateHostname(final String hostname) {
-        return TwitterClientInfo.parseHost(hostname);
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    protected Class<?> getImplementation(final Class<?> type) {
-        return IMPL_MAP.containsKey(type) ? IMPL_MAP.get(type) : type;
-    }
-
-}

src/com/dmdirc/addons/parser_xmpp/XmppChannelClientInfo.java

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2006-2011 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * 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.addons.parser_xmpp;
+
+import com.dmdirc.parser.common.BaseChannelClientInfo;
+import com.dmdirc.parser.interfaces.ChannelClientInfo;
+import com.dmdirc.parser.interfaces.ChannelInfo;
+import com.dmdirc.parser.interfaces.ClientInfo;
+
+/**
+ * An XMPP-specific channel client info object.
+ */
+public class XmppChannelClientInfo extends BaseChannelClientInfo {
+
+    /**
+     * Creates a new client info object for the specified channel and client.
+     *
+     * @param channel The channel the association is with
+     * @param client The user that holds the association
+     */
+    public XmppChannelClientInfo(final ChannelInfo channel, final ClientInfo client) {
+        super(channel, client);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getImportantModePrefix() {
+        return ""; // TODO: Implement
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getImportantMode() {
+        return ""; // TODO: Implement
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getAllModes() {
+        return ""; // TODO: Implement
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void kick(final String message) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int compareTo(final ChannelClientInfo o) {
+        return 0; // TODO: Implement
+    }
+
+}

src/com/dmdirc/addons/parser_xmpp/XmppClientInfo.java

@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) 2006-2011 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * 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.addons.parser_xmpp;
+
+import com.dmdirc.parser.common.BaseClientInfo;
+import com.dmdirc.parser.interfaces.Parser;
+import java.util.ArrayList;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.jivesoftware.smack.RosterEntry;
+import org.jivesoftware.smack.packet.Presence;
+import org.jivesoftware.smack.packet.Presence.Mode;
+import org.jivesoftware.smack.packet.Presence.Type;
+
+/**
+ * An XMPP-specific client info object.
+ */
+public class XmppClientInfo extends BaseClientInfo {
+
+    /** A map of known endpoints for this client. */
+    private final Map<String, XmppEndpoint> endpoints
+            = new HashMap<String, XmppEndpoint>();
+
+    /**
+     * Creates a new XMPP Client Info object with the specified details.
+     *
+     * @param parser The parser that owns this client info object
+     * @param nick The nickname of the user this object represents
+     * @param user The username of the user this object represents
+     * @param host The hostname of the user this object represents
+     */
+    public XmppClientInfo(final Parser parser, final String nick,
+            final String user, final String host) {
+        super(parser, nick, user, host);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int getChannelCount() {
+        return 0;
+    }
+
+    /**
+     * Retrieves the map of known endpoints for this client.
+     *
+     * @return A map of endpoint names to presence states.
+     */
+    public Map<String, XmppEndpoint> getEndpoints() {
+        return Collections.unmodifiableMap(endpoints);
+    }
+
+    /**
+     * Sets the presence of one endpoint of this client.
+     *
+     * @param packet The presence packet received
+     */
+    public void setPresence(final Presence packet) {
+        final String[] parts = getParser().parseHostmask(packet.getFrom());
+        final boolean wasAway = isAway();
+
+        if (packet.getType() == Type.unavailable) {
+            endpoints.remove(parts[1]);
+            return;
+        }
+
+        if (!endpoints.containsKey(parts[1])) {
+            endpoints.put(parts[1], new XmppEndpoint());
+        }
+
+        final XmppEndpoint endpoint = endpoints.get(parts[1]);
+        endpoint.setPriority(packet.getPriority());
+        endpoint.setMode(packet.getMode());
+        endpoint.setType(packet.getType());
+        endpoint.setStatus(packet.getStatus());
+
+        final boolean isAway = isAway();
+
+        if (wasAway != isAway) {
+            // Their away status has changed
+            ((XmppParser) getParser()).handleAwayStateChange(this, wasAway);
+        }
+    }
+
+    /**
+     * Determines whether or not this contact is "away" - that is, their
+     * aggregate presence state is "Unavailable", "Away", "DND" or "XA".
+     *
+     * @return True if the client is away, false otherwise
+     */
+    public boolean isAway() {
+        final Mode presence = getAggregatePresence();
+
+        return presence == null || presence.compareTo(Mode.away) >= 0;
+    }
+
+    /**
+     * Gets the aggregate presence of this contact.
+     *
+     * @return The highest available state of the contact's highest priority
+     * endpoints, or <code>null</code> if no endpoints are available.
+     */
+    public Mode getAggregatePresence() {
+        final List<XmppEndpoint> sortedEndpoints
+                = new ArrayList<XmppEndpoint>(endpoints.values());
+        Collections.sort(sortedEndpoints);
+
+        // Get the set of the highest priority endpoints
+        final Set<XmppEndpoint> bestEndpoints = new HashSet<XmppEndpoint>(sortedEndpoints.size());
+        int best = 0;
+        for (XmppEndpoint endpoint : sortedEndpoints) {
+            if (endpoint.getType() != Type.available) {
+                continue;
+            }
+
+            if (bestEndpoints.isEmpty()) {
+                best = endpoint.getPriority();
+            }
+
+            if (endpoint.getPriority() == best && best >= 0) {
+                bestEndpoints.add(endpoint);
+            }
+        }
+
+        // Find the best presence
+        Mode bestPresence = null;
+        for (XmppEndpoint endpoint : bestEndpoints) {
+            final Mode targetMode = endpoint.getMode() == null ? Mode.available : endpoint.getMode();
+            if (bestPresence == null || bestPresence.compareTo(targetMode) > 0) {
+                bestPresence = targetMode;
+            }
+        }
+
+        return bestPresence;
+    }
+
+    /**
+     * Updates this client with information from the roster.
+     *
+     * @param entry The roster entry to update this client with
+     */
+    public void setRosterEntry(final RosterEntry entry) {
+        setRealname(entry.getName());
+    }
+
+}

src/com/dmdirc/addons/parser_xmpp/XmppEndpoint.java

@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2006-2011 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * 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.addons.parser_xmpp;
+
+import org.jivesoftware.smack.packet.Presence;
+import org.jivesoftware.smack.packet.Presence.Mode;
+import org.jivesoftware.smack.packet.Presence.Type;
+
+/**
+ * Represents a single endpoint of one contact.
+ */
+public class XmppEndpoint implements Comparable<XmppEndpoint> {
+
+    /** The mode of the last presence update. */
+    private Presence.Mode mode;
+    /** The type of the last presence update. */
+    private Presence.Type type;
+    /** The status from the last presence update. */
+    private String status;
+    /** The priority of this endpoint. */
+    private int priority;
+
+    /**
+     * Gets the mode of this endpoint.
+     *
+     * @return The last seen presence mode
+     */
+    public Mode getMode() {
+        return mode;
+    }
+
+    /**
+     * Sets the mode of this endpoint.
+     *
+     * @param mode The most recently received presence mode
+     */
+    public void setMode(final Mode mode) {
+        this.mode = mode;
+    }
+
+    /**
+     * Gets the status of this endpoint.
+     *
+     * @return The last seen presence status
+     */
+    public String getStatus() {
+        return status;
+    }
+
+    /**
+     * Sets the status of this endpoint.
+     *
+     * @param status The most recently received presence status
+     */
+    public void setStatus(final String status) {
+        this.status = status;
+    }
+
+    /**
+     * Gets the type of this endpoint.
+     *
+     * @return The last seen presence type
+     */
+    public Type getType() {
+        return type;
+    }
+
+    /**
+     * Sets the type of this endpoint.
+     *
+     * @param type The most recently received presence type
+     */
+    public void setType(final Type type) {
+        this.type = type;
+    }
+
+    /**
+     * Gets the priority of this endpoint.
+     *
+     * @return The priority of this endpoint
+     */
+    public int getPriority() {
+        return priority;
+    }
+
+    /**
+     * Sets the priority of this endpoint.
+     *
+     * @param priority The new priority for this endpoint
+     */
+    public void setPriority(final int priority) {
+        this.priority = priority;
+    }
+
+    /**
+     * Gets a user-friendly string describing this endpoint's presence.
+     *
+     * @return The presence of this endpoint in a user-friendly format
+     */
+    public String getPresence() {
+        final String statusText = (status == null || status.isEmpty()) ? "" : " (" + status + ")";
+
+        if (type == Type.unavailable) {
+            return "Unavailable" + statusText;
+        } else if (mode == null) {
+            return "Available" + statusText;
+        } else {
+            return getFriendlyMode(mode) + statusText;
+        }
+    }
+
+    /**
+     * Returns a friendly representation of the specified presence mode.
+     *
+     * @param mode The mode being represented
+     * @return A user-friendly string corresponding to the mode
+     */
+    private static String getFriendlyMode(final Mode mode) {
+        switch (mode) {
+            case available:
+                return "Available";
+            case away:
+                return "Away";
+            case chat:
+                return "Chatty";
+            case dnd:
+                return "Do not disturb";
+            case xa:
+                return "Extended Away";
+            default:
+                return mode.toString();
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int compareTo(final XmppEndpoint o) {
+        return o.getPriority() - priority;
+    }
+}

src/com/dmdirc/addons/parser_xmpp/XmppFakeChannel.java

@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2006-2011 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * 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.addons.parser_xmpp;
+
+import com.dmdirc.parser.common.BaseChannelInfo;
+import com.dmdirc.parser.common.ChannelListModeItem;
+import com.dmdirc.parser.interfaces.ChannelClientInfo;
+import com.dmdirc.parser.interfaces.ClientInfo;
+import com.dmdirc.parser.interfaces.Parser;
+import com.dmdirc.parser.interfaces.callbacks.ChannelNamesListener;
+
+import java.util.Collection;
+
+/**
+ * A 'fake' local channel used to display buddy lists.
+ */
+public class XmppFakeChannel extends BaseChannelInfo {
+
+    /**
+     * Creates a new fake channel belonging to the specified parser and
+     * with the given name.
+     *
+     * @param parser The XMPP parser that owns this channel
+     * @param name The name of the channel
+     */
+    public XmppFakeChannel(final Parser parser, final String name) {
+        super(parser, name);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void setTopic(final String topic) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getTopic() {
+        return "No topic yet!";
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public long getTopicTime() {
+        return System.currentTimeMillis(); // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getTopicSetter() {
+        return ""; // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getModes() {
+        return ""; // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getMode(final char mode) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public Collection<ChannelListModeItem> getListMode(final char mode) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void part(final String reason) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void sendWho() {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void alterMode(final boolean add, final Character mode, final String parameter) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void flushModes() {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void requestListModes() {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public ChannelClientInfo getChannelClient(final ClientInfo client) {
+        return getClient(client.getNickname());
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public ChannelClientInfo getChannelClient(final String client, final boolean create) {
+        final String[] parts = getParser().parseHostmask(client);
+        
+        if (create && getClient(parts[0]) == null) {
+            return new XmppChannelClientInfo(this, getParser().getClient(client));
+        }
+        
+        return getClient(parts[0]);
+    }
+    
+    /**
+     * Updates this channel with the specified contacts.
+     *
+     * @param clients The contacts to be added
+     */
+    public void updateContacts(final Collection<XmppClientInfo> clients) {
+        for (XmppClientInfo client : clients) {
+            addClient(client.getNickname(), new XmppChannelClientInfo(this, client));
+        }
+        
+        // TODO: Delete old contacts, don't needlessly create new objects
+        
+        getParser().getCallbackManager().getCallbackType(ChannelNamesListener.class).call(this);
+    }
+
+}

src/com/dmdirc/addons/parser_xmpp/XmppLocalClientInfo.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2006-2011 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * 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.addons.parser_xmpp;
+
+import com.dmdirc.parser.interfaces.LocalClientInfo;
+import com.dmdirc.parser.interfaces.Parser;
+
+/**
+ * A representation of the local XMPP client.
+ */
+public class XmppLocalClientInfo extends XmppClientInfo implements LocalClientInfo {
+
+    /**
+     * Creates a new XMPP Client Info object with the specified details.
+     *
+     * @param parser The parser that owns this client info object
+     * @param nick The nickname of the user this object represents
+     * @param user The username of the user this object represents
+     * @param host The hostname of the user this object represents
+     */
+    public XmppLocalClientInfo(final Parser parser, final String nick,
+            final String user, final String host) {
+        super(parser, nick, user, host);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void setNickname(final String name) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getModes() {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void setAway(final String reason) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void setBack() {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void alterMode(final boolean add, final Character mode) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void flushModes() {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+}

src/com/dmdirc/addons/parser_xmpp/XmppParser.java

@@ -0,0 +1,604 @@
+/*
+ * Copyright (c) 2006-2011 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * 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.addons.parser_xmpp;
+
+import com.dmdirc.parser.common.AwayState;
+import com.dmdirc.parser.common.BaseSocketAwareParser;
+import com.dmdirc.parser.common.ChannelJoinRequest;
+import com.dmdirc.parser.common.DefaultStringConverter;
+import com.dmdirc.parser.common.ParserError;
+import com.dmdirc.parser.common.QueuePriority;
+import com.dmdirc.parser.interfaces.ChannelClientInfo;
+import com.dmdirc.parser.interfaces.ChannelInfo;
+import com.dmdirc.parser.interfaces.ClientInfo;
+import com.dmdirc.parser.interfaces.LocalClientInfo;
+import com.dmdirc.parser.interfaces.StringConverter;
+import com.dmdirc.parser.interfaces.callbacks.CallbackInterface;
+import com.dmdirc.parser.interfaces.callbacks.ChannelSelfJoinListener;
+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.NumericListener;
+import com.dmdirc.parser.interfaces.callbacks.OtherAwayStateListener;
+import com.dmdirc.parser.interfaces.callbacks.PrivateMessageListener;
+import com.dmdirc.parser.interfaces.callbacks.ServerReadyListener;
+import com.dmdirc.parser.interfaces.callbacks.SocketCloseListener;
+
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.jivesoftware.smack.Chat;
+import org.jivesoftware.smack.ChatManagerListener;
+import org.jivesoftware.smack.ConnectionConfiguration;
+import org.jivesoftware.smack.ConnectionListener;
+import org.jivesoftware.smack.MessageListener;
+import org.jivesoftware.smack.PacketListener;
+import org.jivesoftware.smack.RosterEntry;
+import org.jivesoftware.smack.RosterListener;
+import org.jivesoftware.smack.XMPPConnection;
+import org.jivesoftware.smack.XMPPException;
+import org.jivesoftware.smack.filter.PacketFilter;
+import org.jivesoftware.smack.packet.Message;
+import org.jivesoftware.smack.packet.Packet;
+import org.jivesoftware.smack.packet.Presence;
+import org.jivesoftware.smackx.muc.MultiUserChat;
+
+/**
+ * A parser which can understand the XMPP protocol.
+ */
+public class XmppParser extends BaseSocketAwareParser {
+
+    /** A map of this parser's implementations of common interfaces. */
+    private static final Map<Class<?>, Class<?>> IMPL_MAP = new HashMap<Class<?>, Class<?>>();
+
+    static {
+        IMPL_MAP.put(ClientInfo.class, XmppClientInfo.class);
+        IMPL_MAP.put(LocalClientInfo.class, XmppLocalClientInfo.class);
+        IMPL_MAP.put(ChannelInfo.class, XmppFakeChannel.class);
+        IMPL_MAP.put(ChannelClientInfo.class, XmppChannelClientInfo.class);
+    }
+
+    /** The connection to use. */
+    private XMPPConnection connection;
+
+    /** A cache of known chats. */
+    private final Map<String, Chat> chats = new HashMap<String, Chat>();
+
+    /** A cache of known clients. */
+    private final Map<String, XmppClientInfo> contacts = new HashMap<String, XmppClientInfo>();
+
+    /** Whether or not to use a fake local channel for a buddy list replacement. */
+    private final boolean useFakeChannel;
+
+    /** The fake channel to use is useFakeChannel is enabled. */
+    private XmppFakeChannel fakeChannel;
+
+    /**
+     * Creates a new XMPP parser for the specified address.
+     *
+     * @param address The address to connect to
+     */
+    public XmppParser(final URI address) {
+        super(address, IMPL_MAP);
+
+        useFakeChannel = getURI().getQuery() != null && getURI().getQuery().matches("(?i)(^|,)showchannel($|,)");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void disconnect(final String message) {
+        // TODO: Pass quit message on as presence?
+        connection.disconnect();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void joinChannels(final ChannelJoinRequest... channels) {
+        for (ChannelJoinRequest request : channels) {
+            final MultiUserChat muc = new MultiUserChat(connection, request.getName().substring(1));
+
+            try {
+                if (request.getPassword() == null) {
+                    muc.join(getLocalClient().getNickname());
+                } else {
+                    muc.join(getLocalClient().getNickname(), request.getPassword());
+                }
+
+                // TODO: Send callbacks etc
+            } catch (XMPPException ex) {
+                // TODO: handle
+            }
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public ChannelInfo getChannel(final String channel) {
+        // TODO: Implement
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public Collection<? extends ChannelInfo> getChannels() {
+        return Collections.<ChannelInfo>emptyList();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int getMaxLength(final String type, final String target) {
+        return -1; // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int getMaxLength() {
+        return -1; // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public LocalClientInfo getLocalClient() {
+        final String[] parts = parseHostmask(connection.getUser());
+
+        // TODO: Cache this
+        return new XmppLocalClientInfo(this, parts[0], parts[2], parts[1]);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public XmppClientInfo getClient(final String details) {
+        final String[] parts = parseHostmask(details);
+
+        if (!contacts.containsKey(parts[0])) {
+            contacts.put(parts[0], new XmppClientInfo(this, parts[0], parts[2], parts[1]));
+        }
+
+        return contacts.get(parts[0]);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void sendRawMessage(final String message) {
+        // Urgh, hacky horrible rubbish. These commands should call methods.
+        if (message.toUpperCase().startsWith("WHOIS ")) {
+            handleWhois(message.split(" ")[1]);
+        }
+    }
+
+    /**
+     * Handles a whois request for the specified target.
+     *
+     * @param target The user being WHOIS'd
+     */
+    private void handleWhois(final String target) {
+        // Urgh, hacky horrible rubbish. This should be abstracted.
+        if (contacts.containsKey(target)) {
+            final XmppClientInfo client = contacts.get(target);
+            final String[] userParts = client.getNickname().split("@", 2);
+
+            callNumericCallback(311, target, userParts[0], userParts[1], "*", client.getRealname());
+
+            for (Map.Entry<String, XmppEndpoint> endpoint : client.getEndpoints().entrySet()) {
+                callNumericCallback(399, target, endpoint.getKey(),
+                        "(" + endpoint.getValue().getPresence() + ")", "has endpoint");
+            }
+        } else {
+            callNumericCallback(401, target, "No such contact found");
+        }
+
+        callNumericCallback(318, target, "End of /WHOIS.");
+    }
+
+    private void callNumericCallback(final int numeric, final String ... args) {
+        final String[] newArgs = new String[args.length + 3];
+        newArgs[0] = ":xmpp.server";
+        newArgs[1] = (numeric < 100 ? "0" : "") + (numeric < 10 ? "0" : "") + numeric;
+        newArgs[2] = getLocalClient().getNickname();
+        System.arraycopy(args, 0, newArgs, 3, args.length);
+
+        getCallbackManager().getCallbackType(NumericListener.class).call(numeric, newArgs);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void sendRawMessage(final String message, final QueuePriority priority) {
+        sendRawMessage(message);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public StringConverter getStringConverter() {
+        return new DefaultStringConverter();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean isValidChannelName(final String name) {
+        return false; // TODO: Implement
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean compareURI(final URI uri) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public Collection<? extends ChannelJoinRequest> extractChannels(final URI uri) {
+        return Collections.<ChannelJoinRequest>emptyList();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getServerName() {
+        return connection.getServiceName();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getNetworkName() {
+        return "XMPP"; // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getServerSoftware() {
+        return "Unknown"; // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getServerSoftwareType() {
+        return "XMPP"; // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public List<String> getServerInformationLines() {
+        return Collections.<String>emptyList(); // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int getMaxTopicLength() {
+        return 0; // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getBooleanChannelModes() {
+        return ""; // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getListChannelModes() {
+        return ""; // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int getMaxListModes(final char mode) {
+        return 0; // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean isUserSettable(final char mode) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getParameterChannelModes() {
+        return ""; // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getDoubleParameterChannelModes() {
+        return ""; // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getUserModes() {
+        return ""; // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getChannelUserModes() {
+        return ""; // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getChannelPrefixes() {
+        return "#";
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public long getServerLatency() {
+        return 1000l; // TODO
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void sendCTCP(final String target, final String type, final String message) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void sendCTCPReply(final String target, final String type, final String message) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void sendMessage(final String target, final String message) {
+        if (!chats.containsKey(target)) {
+            chats.put(target, connection.getChatManager().createChat(target, new MessageListenerImpl()));
+        }
+
+        try {
+            chats.get(target).sendMessage(message);
+        } catch (XMPPException ex) {
+            // TODO: Handle this
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void sendNotice(final String target, final String message) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void sendAction(final String target, final String message) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void sendInvite(final String channel, final String user) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getLastLine() {
+        return "TODO: Implement me";
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String[] parseHostmask(final String hostmask) {
+        return new XmppProtocolDescription().parseHostmask(hostmask);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public long getPingTime() {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void run() {
+        final String[] userInfoParts = getURI().getUserInfo().split(":", 2);
+        final String[] userParts = userInfoParts[0].split("@", 2);
+
+        final ConnectionConfiguration config = new ConnectionConfiguration(getURI().getHost(), getURI().getPort(), userParts[0]);
+        config.setSecurityMode(getURI().getScheme().equalsIgnoreCase("xmpps")
+                ? ConnectionConfiguration.SecurityMode.required
+                : ConnectionConfiguration.SecurityMode.disabled);
+        config.setSASLAuthenticationEnabled(true);
+        config.setReconnectionAllowed(false);
+        config.setRosterLoadedAtLogin(true);
+        config.setSocketFactory(getSocketFactory());
+        connection = new XMPPConnection(config);
+
+        try {
+            connection.connect();
+
+            connection.addConnectionListener(new ConnectionListenerImpl());
+            connection.addPacketListener(new PacketListenerImpl(DataInListener.class), new AcceptAllPacketFilter());
+            connection.addPacketWriterListener(new PacketListenerImpl(DataOutListener.class), new AcceptAllPacketFilter());
+            connection.getChatManager().addChatListener(new ChatManagerListenerImpl());
+
+            connection.login(userInfoParts[0], userInfoParts[1], "DMDirc.");
+
+            connection.getRoster().addRosterListener(new RosterListenerImpl());
+
+            getCallbackManager().getCallbackType(ServerReadyListener.class).call();
+
+            for (RosterEntry contact : connection.getRoster().getEntries()) {
+                getClient(contact.getUser()).setRosterEntry(contact);
+            }
+
+            if (useFakeChannel) {
+                fakeChannel = new XmppFakeChannel(this, "&contacts");
+                getCallbackManager().getCallbackType(ChannelSelfJoinListener.class).call(fakeChannel);
+                fakeChannel.updateContacts(contacts.values());
+            }
+        } catch (XMPPException ex) {
+            final ParserError error = new ParserError(ParserError.ERROR_ERROR, "Unable to connect", "");
+
+            if (ex.getCause() instanceof IOException) {
+                // Pass along the underlying socket error instead of an XMPP
+                // specific one
+                error.setException((IOException) ex.getCause());
+            } else {
+                error.setException(ex);
+            }
+
+            getCallbackManager().getCallbackType(ConnectErrorListener.class).call(error);
+        }
+    }
+
+    /**
+     * Handles a client's away state changing.
+     *
+     * @param client The client whose state is changing
+     * @param isBack True if the client is coming back, false if they're going away
+     */
+    public void handleAwayStateChange(final XmppClientInfo client, final boolean isBack) {
+        if (useFakeChannel) {
+            getCallbackManager().getCallbackType(OtherAwayStateListener.class)
+                    .call(client, isBack ? AwayState.AWAY : AwayState.HERE,
+                    isBack ? AwayState.HERE : AwayState.AWAY);
+        }
+    }
+
+    private class ConnectionListenerImpl implements ConnectionListener {
+
+        /** {@inheritDoc} */
+        @Override
+        public void connectionClosed() {
+            getCallbackManager().getCallbackType(SocketCloseListener.class).call();
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public void connectionClosedOnError(final Exception excptn) {
+            // TODO: Handle exception
+            getCallbackManager().getCallbackType(SocketCloseListener.class).call();
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public void reconnectingIn(final int i) {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public void reconnectionSuccessful() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public void reconnectionFailed(final Exception excptn) {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+    }
+
+    private class RosterListenerImpl implements RosterListener {
+
+        /** {@inheritDoc} */
+        @Override
+        public void entriesAdded(final Collection<String> clctn) {
+            System.out.println("Added: " + clctn);
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public void entriesUpdated(final Collection<String> clctn) {
+            System.out.println("Updated: " + clctn);
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public void entriesDeleted(final Collection<String> clctn) {
+            System.out.println("Deleted: " + clctn);
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public void presenceChanged(final Presence prsnc) {
+            getClient(prsnc.getFrom()).setPresence(prsnc);
+        }
+
+    }
+
+    private class ChatManagerListenerImpl implements ChatManagerListener {
+
+        /** {@inheritDoc} */
+        @Override
+        public void chatCreated(final Chat chat, final boolean bln) {
+            if (!bln) {
+                // Only add chats that weren't created locally
+                chats.put(parseHostmask(chat.getParticipant())[0], chat);
+                chat.addMessageListener(new MessageListenerImpl());
+            }
+        }
+
+    }
+
+    private class MessageListenerImpl implements MessageListener {
+
+        /** {@inheritDoc} */
+        @Override
+        public void processMessage(final Chat chat, final Message msg) {
+            if (msg.getBody() != null) {
+                // TOOD: Handle error messages
+                getCallbackManager().getCallbackType(PrivateMessageListener.class).call(msg.getBody(), msg.getFrom());
+            }
+        }
+
+    }
+
+    private class PacketListenerImpl implements PacketListener {
+
+        private final Class<? extends CallbackInterface> callback;
+
+        public PacketListenerImpl(final Class<? extends CallbackInterface> callback) {
+            this.callback = callback;
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public void processPacket(final Packet packet) {
+            if (callback.equals(DataOutListener.class)) {
+                getCallbackManager().getCallbackType(callback).call(packet.toXML(), true);
+            } else {
+                getCallbackManager().getCallbackType(callback).call(packet.toXML());
+            }
+        }
+
+    }
+
+    private static class AcceptAllPacketFilter implements PacketFilter {
+
+        /** {@inheritDoc} */
+        @Override
+        public boolean accept(final Packet packet) {
+            return true;
+        }
+
+    }
+
+}

src/com/dmdirc/addons/parser_xmpp/XmppPlugin.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2006-2011 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * 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.addons.parser_xmpp;
+
+import com.dmdirc.parser.common.MyInfo;
+import com.dmdirc.parser.interfaces.Parser;
+import com.dmdirc.parser.interfaces.ProtocolDescription;
+import com.dmdirc.plugins.Plugin;
+import java.net.URI;
+
+/**
+ * Plugin that provides a parser to connect to XMPP services.
+ */
+public class XmppPlugin extends Plugin {
+
+    /** {@inheritDoc} */
+    @Override
+    public void onLoad() {
+        // Do nothing
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void onUnload() {
+        // Do nothing
+    }
+    
+    /**
+     * Creates a new XMPP parser for the specified client info and address.
+     *
+     * @param myInfo The settings for the local client
+     * @param address The address to connect to
+     * @return An appropriately configured parser
+     */
+    public Parser getParser(final MyInfo myInfo, final URI address) {
+        return new XmppParser(address);
+    }
+    
+    /**
+     * Retrieves an object describing the properties of the XMPP protocol.
+     *
+     * @return A relevant protocol description object
+     */
+    public ProtocolDescription getDescription() {
+        return new XmppProtocolDescription();
+    }
+
+}

src/com/dmdirc/addons/parser_twitter/TwitterCallbackManager.java → src/com/dmdirc/addons/parser_xmpp/XmppProtocolDescription.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ * Copyright (c) 2006-2011 Chris Smith, Shane Mc Cormack, Gregory Holmes
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -20,39 +20,26 @@
  * SOFTWARE.
  */
 
-package com.dmdirc.addons.parser_twitter;
+package com.dmdirc.addons.parser_xmpp;
 
-import com.dmdirc.parser.common.CallbackManager;
-import com.dmdirc.parser.common.CallbackObject;
-import com.dmdirc.parser.common.CallbackObjectSpecific;
-import com.dmdirc.parser.interfaces.callbacks.CallbackInterface;
+import com.dmdirc.parser.interfaces.ProtocolDescription;
 
 /**
- * Handles callbacks for the Twitter Parser.
- * 
- * @author chris
+ * A description of the XMPP protocol.
  */
-public class TwitterCallbackManager extends CallbackManager<Twitter> {
-
-    /**
-     * Create a new TwitterCallbackManager
-     * 
-     * @param parser Parser that owns this callback manager.
-     */
-    public TwitterCallbackManager(final Twitter parser) {
-        super(parser);
-    }
+public class XmppProtocolDescription implements ProtocolDescription {
 
     /** {@inheritDoc} */
     @Override
-    protected CallbackObject getCallbackObject(final Twitter parser, final Class<?> type) {
-        return new TwitterCallbackObject(parser, this, type.asSubclass(CallbackInterface.class));
+    public int getDefaultPort() {
+        return 5222;
     }
 
     /** {@inheritDoc} */
     @Override
-    protected CallbackObjectSpecific getSpecificCallbackObject(final Twitter parser, final Class<?> type) {
-        return new TwitterCallbackObjectSpecific(parser, this, type.asSubclass(CallbackInterface.class));
+    public String[] parseHostmask(final String hostmask) {
+        final String[] parts = hostmask.split("/");
+        return new String[] { parts[0], parts.length > 1 ? parts[1] : "unknown", "" };
     }
 
 }

src/com/dmdirc/addons/parser_xmpp/plugin.config

@@ -0,0 +1,34 @@
+# This is a DMDirc configuration file.
+
+# This section indicates which sections below take key/value
+# pairs, rather than a simple list. It should be placed above
+# any sections that take key/values.
+keysections:
+  metadata
+  updates
+  version
+  defaults
+  icons
+
+metadata:
+  author=Chris <chris@dmdirc.com>
+  mainclass=com.dmdirc.addons.parser_xmpp.XmppPlugin
+  description=Provides XMPP access for DMDirc.
+  name=xmpp
+  nicename=XMPP Plugin
+
+updates:
+  id=63
+
+version:
+  number=1
+  friendly=0.1
+
+provides:
+  xmpp parser
+  xmpps parser
+
+
+exports:
+  getParser in com.dmdirc.addons.parser_xmpp.XmppPlugin as getParser
+  getDescription in com.dmdirc.addons.parser_xmpp.XmppPlugin as getProtocolDescription

src/com/dmdirc/addons/relaybot/RelayCallbackManager.java

@@ -31,7 +31,6 @@ import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.interfaces.callbacks.CallbackInterface;
 import com.dmdirc.parser.interfaces.callbacks.ChannelMessageListener;
 import com.dmdirc.parser.interfaces.callbacks.SocketCloseListener;
-import com.dmdirc.parser.irc.IRCCallbackManager;
 import com.dmdirc.parser.irc.IRCParser;
 
 import java.lang.reflect.Field;
@@ -49,13 +48,13 @@ import java.util.Map;
  *
  * @author shane
  */
-public class RelayCallbackManager extends IRCCallbackManager implements SocketCloseListener {
+public class RelayCallbackManager extends CallbackManager implements SocketCloseListener {
 
     /** Pluign that created this callback manager. */
     private final RelayBotPlugin myPlugin;
 
     /** Original CallbackManager */
-    private final IRCCallbackManager originalCBM;
+    private final CallbackManager originalCBM;
 
     /**
      * Create a new RelayCallbackManager and replace
@@ -64,17 +63,17 @@ public class RelayCallbackManager extends IRCCallbackManager implements SocketCl
      * @param parser
      */
     public RelayCallbackManager(final RelayBotPlugin myPlugin, final IRCParser parser) {
-        super(parser);
+        super(parser, IRCParser.IMPL_MAP);
 
         this.myPlugin = myPlugin;
-        this.originalCBM = (IRCCallbackManager) parser.getCallbackManager();
+        this.originalCBM = parser.getCallbackManager();
         setCallbackManager(parser, this);
         addCallback(SocketCloseListener.class, this);
     }
 
     /** {@inheritDoc} */
     @Override
-    public <T extends CallbackInterface> void addCallback(final Class<T> callback, final T o, final String target) throws CallbackNotFoundException {
+    public <S extends CallbackInterface> void addCallback(final Class<S> callback, final S o, final String target) throws CallbackNotFoundException {
         // Don't allow the core to give itself a ChannelMessageListener if we
         // already have a listener for this channel.
         if (o instanceof ChannelEventHandler && callback == ChannelMessageListener.class) {
@@ -125,13 +124,13 @@ public class RelayCallbackManager extends IRCCallbackManager implements SocketCl
      * @param parser
      * @param cbm
      */
-    private void setCallbackManager(final IRCParser parser, final CallbackManager<IRCParser> cbm) {
+    private void setCallbackManager(final IRCParser parser, final CallbackManager cbm) {
         try {
             // Get the old callback manager
             final Field field = parser.getClass().getDeclaredField("myCallbackManager");
             field.setAccessible(true);
             @SuppressWarnings("unchecked")
-            final CallbackManager<IRCParser> oldCBM = (CallbackManager<IRCParser>) field.get(parser);
+            final CallbackManager oldCBM = (CallbackManager) field.get(parser);
 
             // Clone the known CallbackObjects list (horrible code ahoy!)
             // First get the old map of callbacks

src/com/dmdirc/addons/relaybot/RelayChannelHandler.java

@@ -25,11 +25,11 @@ package com.dmdirc.addons.relaybot;
 import com.dmdirc.Channel;
 import com.dmdirc.ChannelEventHandler;
 import com.dmdirc.config.IdentityManager;
+import com.dmdirc.parser.common.CallbackManager;
 import com.dmdirc.parser.interfaces.ChannelClientInfo;
 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.interfaces.callbacks.ChannelMessageListener;
-import com.dmdirc.parser.irc.IRCCallbackManager;
 import com.dmdirc.parser.irc.IRCChannelClientInfo;
 import com.dmdirc.parser.irc.IRCParser;
 import com.dmdirc.plugins.PluginInfo;
@@ -94,8 +94,8 @@ public class RelayChannelHandler implements ChannelMessageListener {
         coreChannelHandler = ceh;
 
         if (coreChannelHandler != null) {
-            final IRCCallbackManager cbm = (IRCCallbackManager) myChannel
-                    .getServer().getParser().getCallbackManager();
+            final CallbackManager cbm = myChannel.getServer().getParser()
+                    .getCallbackManager();
             cbm.delCallback(ChannelMessageListener.class, coreChannelHandler);
             cbm.addCallback(ChannelMessageListener.class, this,
                     myChannel.getName());
@@ -181,8 +181,8 @@ public class RelayChannelHandler implements ChannelMessageListener {
      */
     public void restoreCoreChannelHandler() {
         if (coreChannelHandler != null) {
-            final IRCCallbackManager cbm = (IRCCallbackManager) myChannel
-                    .getServer().getParser().getCallbackManager();
+            final CallbackManager cbm = myChannel.getServer().getParser()
+                    .getCallbackManager();
 
             // Force adding this callback to the CBM.
             if (cbm instanceof RelayCallbackManager) {