Make callback manager an eventbus.

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

@@ -24,7 +24,6 @@ package com.dmdirc.parser.common;
 
 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.ClientInfo;
-import com.dmdirc.parser.interfaces.callbacks.CallbackInterface;
 
 import java.net.InetSocketAddress;
 import java.net.Proxy;
@@ -32,9 +31,7 @@ import java.net.ProxySelector;
 import java.net.SocketAddress;
 import java.net.URI;
 import java.net.URISyntaxException;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 
 /**
  * Implements common base functionality for parsers.
@@ -79,16 +76,7 @@ public abstract class BaseParser extends ThreadedParser {
     public BaseParser(final URI uri) {
         this.uri = uri;
 
-        final Map<Class<?>, Class<?>> implementations = new HashMap<>();
-
-        for (Class<?> child : getClass().getAnnotation(ChildImplementations.class).value()) {
-            for (Class<?> iface : child.getInterfaces()) {
-                implementations.put(iface, child);
-            }
-        }
-
-        callbackManager = new CallbackManager(implementations);
-        callbackManager.initialise(this);
+        callbackManager = new CallbackManager(this);
     }
 
     @Override
@@ -161,20 +149,6 @@ public abstract class BaseParser extends ThreadedParser {
         return callbackManager;
     }
 
-    /**
-     * Gets a proxy object which can be used to despatch callbacks of the
-     * specified type. Callers may pass <code>null</code> for the first two
-     * arguments of any callback, and these will automatically be replaced
-     * by the relevant Parser instance and the current date.
-     *
-     * @param <T> The type of the callback to retrieve
-     * @param callback The callback to retrieve
-     * @return A proxy object which can be used to call the specified callback
-     */
-    protected <T extends CallbackInterface> T getCallback(final Class<T> callback) {
-        return callbackManager.getCallback(callback);
-    }
-
     @Override
     public void joinChannel(final String channel) {
         joinChannels(new ChannelJoinRequest(channel));

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

@@ -22,354 +22,78 @@
 
 package com.dmdirc.parser.common;
 
+import com.dmdirc.parser.events.ParserErrorEvent;
+import com.dmdirc.parser.events.ParserEvent;
 import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.interfaces.SpecificCallback;
-import com.dmdirc.parser.interfaces.callbacks.AuthNoticeListener;
-import com.dmdirc.parser.interfaces.callbacks.AwayStateListener;
-import com.dmdirc.parser.interfaces.callbacks.CallbackInterface;
-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.ChannelJoinListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelKickListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelListModeListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelMessageListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelModeChangeListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelModeMessageListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelModeNoticeListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelNamesListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelNickChangeListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelNonUserModeChangeListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelNoticeListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelOtherAwayStateListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelPartListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelQuitListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelSelfJoinListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelSingleModeChangeListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelTopicListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelUserModeChangeListener;
-import com.dmdirc.parser.interfaces.callbacks.CompositionStateChangeListener;
-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.GroupListEndListener;
-import com.dmdirc.parser.interfaces.callbacks.GroupListEntryListener;
-import com.dmdirc.parser.interfaces.callbacks.GroupListStartListener;
-import com.dmdirc.parser.interfaces.callbacks.InviteListener;
-import com.dmdirc.parser.interfaces.callbacks.MotdEndListener;
-import com.dmdirc.parser.interfaces.callbacks.MotdLineListener;
-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.NickInUseListener;
-import com.dmdirc.parser.interfaces.callbacks.NumericListener;
-import com.dmdirc.parser.interfaces.callbacks.OtherAwayStateListener;
-import com.dmdirc.parser.interfaces.callbacks.PasswordRequiredListener;
-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.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.QuitListener;
-import com.dmdirc.parser.interfaces.callbacks.ServerErrorListener;
-import com.dmdirc.parser.interfaces.callbacks.ServerNoticeListener;
-import com.dmdirc.parser.interfaces.callbacks.ServerReadyListener;
-import com.dmdirc.parser.interfaces.callbacks.SocketCloseListener;
-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 com.dmdirc.parser.interfaces.callbacks.UnknownServerNoticeListener;
-import com.dmdirc.parser.interfaces.callbacks.UserModeChangeListener;
-import com.dmdirc.parser.interfaces.callbacks.UserModeDiscoveryListener;
-import com.dmdirc.parser.interfaces.callbacks.WallDesyncListener;
-import com.dmdirc.parser.interfaces.callbacks.WallopListener;
-import com.dmdirc.parser.interfaces.callbacks.WalluserListener;
 
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.Method;
-import java.lang.reflect.Proxy;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
+import com.google.common.base.Throwables;
+
+import java.util.Date;
+
+import net.engio.mbassy.bus.MBassador;
+import net.engio.mbassy.bus.config.BusConfiguration;
+import net.engio.mbassy.bus.config.Feature;
 
 /**
  * Parser Callback Manager.
  * Manages adding/removing/calling callbacks.
  */
-public 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,
-        ChannelNickChangeListener.class,
-        ChannelNonUserModeChangeListener.class,
-        ChannelModeMessageListener.class,
-        ChannelModeNoticeListener.class,
-        ChannelNoticeListener.class,
-        ChannelPartListener.class,
-        ChannelQuitListener.class,
-        ChannelSelfJoinListener.class,
-        ChannelSingleModeChangeListener.class,
-        ChannelTopicListener.class,
-        ChannelUserModeChangeListener.class,
-        CompositionStateChangeListener.class,
-        ConnectErrorListener.class,
-        DataInListener.class,
-        DataOutListener.class,
-        DebugInfoListener.class,
-        ErrorInfoListener.class,
-        GroupListStartListener.class,
-        GroupListEntryListener.class,
-        GroupListEndListener.class,
-        NetworkDetectedListener.class,
-        InviteListener.class,
-        MotdEndListener.class,
-        MotdLineListener.class,
-        MotdStartListener.class,
-        NickChangeListener.class,
-        NickInUseListener.class,
-        AuthNoticeListener.class,
-        NumericListener.class,
-        PasswordRequiredListener.class,
-        PingFailureListener.class,
-        PingSuccessListener.class,
-        PingSentListener.class,
-        PrivateActionListener.class,
-        PrivateCtcpListener.class,
-        PrivateCtcpReplyListener.class,
-        PrivateMessageListener.class,
-        PrivateNoticeListener.class,
-        QuitListener.class,
-        ServerErrorListener.class,
-        ServerReadyListener.class,
-        SocketCloseListener.class,
-        UnknownActionListener.class,
-        UnknownCtcpListener.class,
-        UnknownCtcpReplyListener.class,
-        UnknownMessageListener.class,
-        UnknownNoticeListener.class,
-        UserModeChangeListener.class,
-        UserModeDiscoveryListener.class,
-        WallDesyncListener.class,
-        WallopListener.class,
-        WalluserListener.class,
-        ServerNoticeListener.class,
-        UnknownServerNoticeListener.class,
-    };
-
-    /** Hashtable used to store the different types of callback known. */
-    private final Map<Class<? extends CallbackInterface>, CallbackObject> callbackHash
-            = new HashMap<>();
-
-    /** A map of implementations to use for parser interfaces. */
-    private final Map<Class<?>, Class<?>> implementationMap;
-
-    /**
-     * Constructor to create a CallbackManager.
-     *
-     * @param implementationMap A map of implementations to use
-     */
-    public CallbackManager(final Map<Class<?>, Class<?>> implementationMap) {
-        this.implementationMap = Collections.unmodifiableMap(implementationMap);
-    }
-
-    /**
-     * Initialises this callback manager.
-     *
-     * @param parser The parser associated with this CallbackManager
-     */
-    public void initialise(final Parser parser) {
-        for (Class<?> type : CLASSES) {
-            if (type.isAnnotationPresent(SpecificCallback.class)) {
-                addCallbackType(getSpecificCallbackObject(parser, type));
-            } else {
-                addCallbackType(getCallbackObject(parser, type));
-            }
-        }
-    }
-
-    /**
-     * Retrieves a relevant {@link CallbackObject} for the specified type.
-     *
-     * @param parser The parser that this manager belongs to
-     * @param type The type of callback to create an object for
-     * @return The relevant CallbackObject
-     */
-    protected CallbackObject getCallbackObject(final Parser parser, final Class<?> type) {
-        return new CallbackObject(parser, this, type.asSubclass(CallbackInterface.class),
-                implementationMap);
-    }
-
-    /**
-     * Retrieves a relevant {@link CallbackObjectSpecific} for the specified type.
-     *
-     * @param parser The parser that this manager belongs to
-     * @param type The type of callback to create an object for
-     * @return The relevant CallbackObject
-     */
-    protected CallbackObjectSpecific getSpecificCallbackObject(
-            final Parser parser, final Class<?> type) {
-        return new CallbackObjectSpecific(parser, this, type.asSubclass(CallbackInterface.class),
-                implementationMap);
-    }
-
-    /**
-     * Add new callback type.
-     *
-     * @param callback CallbackObject subclass for the callback.
-     */
-    private void addCallbackType(final CallbackObject callback) {
-        if (!callbackHash.containsKey(callback.getType())) {
-            callbackHash.put(callback.getType(), callback);
-        }
-    }
-
-    /**
-     * Get reference to callback object.
-     *
-     * @param callback Name of type of callback object.
-     * @return CallbackObject returns the callback object for this type
-     */
-    private 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) {
-        callbackHash.values().stream()
-                .filter(cb -> cb != null && cb.getType().isInstance(o))
-                .forEach(cb -> cb.del(o));
+public class CallbackManager extends MBassador<ParserEvent> {
+
+    private final Object errorHandlerLock = new Object();
+    private final Parser parser;
+
+    public CallbackManager(final Parser parser) {
+        super(new BusConfiguration().addFeature(Feature.SyncPubSub.Default())
+                .addFeature(Feature.AsynchronousHandlerInvocation.Default(1, 1)).addFeature(
+                        Feature.AsynchronousMessageDispatch.Default()
+                                .setNumberOfMessageDispatchers(1)));
+        this.parser = parser;
+        setupErrorHandler();
     }
 
-    /**
-     * Add all callbacks that this object implements.
-     *
-     * @param o instance of ICallbackInterface to add.
-     */
-    public void addAllCallback(final CallbackInterface o) {
-        callbackHash.values().stream()
-                .filter(cb -> cb != null && cb.getType().isInstance(o))
-                .forEach(cb -> cb.add(o));
+    @SuppressWarnings("TypeMayBeWeakened")
+    public CallbackManager(final BusConfiguration configuration, final Parser parser) {
+        super(configuration);
+        setupErrorHandler();
+        this.parser = parser;
     }
 
-    /**
-     * Add a callback.
-     * This method will throw a CallbackNotFoundException if the callback does not exist.
-     *
-     * @param <S> 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 <S extends CallbackInterface> void addCallback(
-            final Class<S> callback, final S o) throws CallbackNotFoundException {
-        if (o == null) {
-            throw new NullPointerException("CallbackInterface is null");
-        }
-
-        final CallbackObject cb = getCallbackType(callback);
-
-        if (cb != null) {
-            cb.add(o);
+    @Override
+    public void publish(final ParserEvent message) {
+        // TODO: HACKY REMOVE
+        if (message.getParser() == null) {
+            message.setParser(parser);
         }
-    }
-
-    /**
-     * Add a callback with a specific target.
-     * This method will throw a CallbackNotFoundException if the callback does not exist.
-     *
-     * @param <S> 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 <S extends CallbackInterface> void addCallback(
-            final Class<S> callback,
-            final S o, final String target) throws CallbackNotFoundException {
-        if (o == null) {
-            throw new NullPointerException("CallbackInterface is null");
+        if (message.getDate() == null) {
+            message.setDate(new Date());
         }
-
-        ((CallbackObjectSpecific) getCallbackType(callback)).add(o, target);
-    }
-
-    /**
-     * 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);
-    }
-
-    /**
-     * Gets a proxy object which can be used to despatch callbacks of the
-     * specified type. Callers may pass <code>null</code> for the first two
-     * arguments of any callback, and these will automatically be replaced
-     * by the relevant Parser instance and the current date.
-     *
-     * @param <T> The type of the callback to retrieve
-     * @param callback The callback to retrieve
-     * @return A proxy object which can be used to call the specified callback
-     */
-    @SuppressWarnings({"unchecked", "rawtypes"})
-    public <T extends CallbackInterface> T getCallback(final Class<T> callback) {
-        return (T) Proxy.newProxyInstance(getClass().getClassLoader(),
-                new Class[]{ callback }, new CallbackHandler(callback));
+        // TODO: HACKY REMOVE
+        super.publish(message);
     }
 
-    /**
-     * A Proxy invocation handler for a specified parser callback.
-     */
-    private class CallbackHandler implements InvocationHandler {
-
-        /** The callback that should be called. */
-        private final Class<? extends CallbackInterface> callback;
-
-        /**
-         * Creates a new callback handler for the specified callback.
-         *
-         * @param callback The callback to handle
-         */
-        public CallbackHandler(final Class<? extends CallbackInterface> callback) {
-            this.callback = callback;
-        }
-
-        @Override
-        public Object invoke(final Object proxy, final Method method, final Object[] args) {
-            getCallbackType(callback).call(args);
-            return null;
-        }
+    @SuppressWarnings({
+            "ThrowableResultOfMethodCallIgnored",
+            "CallToPrintStackTrace",
+            "UseOfSystemOutOrSystemErr"
+    })
+    private void setupErrorHandler() {
+        addErrorHandler(e -> {
+            if (Thread.holdsLock(errorHandlerLock)) {
+                // ABORT ABORT ABORT - we're publishing an error on the same thread we just tried
+                // to publish an error on. Something in the error reporting pipeline must be
+                // breaking, so don't try adding any more errors.
+                System.err.println("ERROR: Error when reporting error");
+                e.getCause().printStackTrace();
+                return;
+            }
 
+            synchronized (errorHandlerLock) {
+                final Throwable error = e.getCause().getCause();
+                publish(new ParserErrorEvent(parser, new Date(),
+                        new ParserError(ParserError.ERROR_EXCEPTION,
+                        error.getMessage(), Throwables.getStackTraceAsString(error))));
+            }
+        });
     }
 }

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

@@ -1,287 +0,0 @@
-/*
- * Copyright (c) 2006-2015 DMDirc Developers
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-package com.dmdirc.parser.common;
-
-import com.dmdirc.parser.interfaces.FakableArgument;
-import com.dmdirc.parser.interfaces.FakableSource;
-import com.dmdirc.parser.interfaces.Parser;
-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;
-import java.lang.reflect.Method;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.CopyOnWriteArrayList;
-
-/**
- * Superclass for all callback types.
- */
-public class CallbackObject {
-
-    /** The type of callback that this object is operating with. */
-    protected final Class<? extends CallbackInterface> type;
-
-    /** Arraylist for storing callback information related to the callback. */
-    protected final List<CallbackInterface> callbackInfo
-            = new CopyOnWriteArrayList<>();
-
-    /** Reference to the Parser that owns this callback. */
-    protected Parser myParser;
-
-    /** Reference to the CallbackManager in charge of this callback. */
-    protected CallbackManager myManager;
-
-    /** A map of interfaces to their concrete implementations. */
-    private final Map<Class<?>, Class<?>> implementationMap;
-
-    /**
-     * Create a new instance of the Callback Object.
-     *
-     * @param parser Parser That owns this callback
-     * @param manager CallbackManager that is in charge of this callback
-     * @param type The type of callback to use
-     * @param implementationMap A map of interfaces to their parser-specific
-     * implementations
-     * @since 0.6.6
-     */
-    public CallbackObject(final Parser parser, final CallbackManager manager,
-            final Class<? extends CallbackInterface> type,
-            final Map<Class<?>, Class<?>> implementationMap) {
-        this.myParser = parser;
-        this.myManager = manager;
-        this.type = type;
-        this.implementationMap = implementationMap;
-    }
-
-    /**
-     * Add a callback pointer to the appropriate ArrayList.
-     *
-     * @param eMethod OBject to callback to.
-     */
-    protected final void addCallback(final CallbackInterface eMethod) {
-        if (!callbackInfo.contains(eMethod)) {
-            callbackInfo.add(eMethod);
-        }
-    }
-
-    /**
-     * Delete a callback pointer from the appropriate ArrayList.
-     *
-     * @param eMethod Object that was being called back to.
-     */
-    protected final void delCallback(final CallbackInterface eMethod) {
-        callbackInfo.remove(eMethod);
-    }
-
-    /**
-     * Call the OnErrorInfo callback.
-     *
-     * @param errorInfo ParserError object to pass as error.
-     */
-    protected final void callErrorInfo(final ParserError errorInfo) {
-        myManager.getCallback(ErrorInfoListener.class).onErrorInfo(myParser, new Date(), errorInfo);
-    }
-
-    /**
-     * Add a new callback.
-     *
-     * @param eMethod Object to callback to.
-     */
-    public void add(final CallbackInterface eMethod) {
-        addCallback(eMethod);
-    }
-
-    /**
-     * Remove a callback.
-     *
-     * @param eMethod Object to remove callback to.
-     */
-    public void del(final CallbackInterface eMethod) {
-        delCallback(eMethod);
-    }
-
-    /**
-     * 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.
-     *
-     * @param args The arguments to pass to the callback implementation
-     */
-    public void call(final Object... args) {
-        createFakeArgs(args);
-
-        for (CallbackInterface iface : callbackInfo) {
-            try {
-                type.getMethods()[0].invoke(iface, args);
-            } catch (SecurityException | IllegalAccessException |
-                    IllegalArgumentException | InvocationTargetException e) {
-                if (getType().equals(ErrorInfoListener.class)) {
-                    System.out.printf("Exception in onError Callback. [%s]\n", e.getMessage());
-                    e.printStackTrace();
-                } else {
-                    final ParserError ei = new ParserError(ParserError.ERROR_ERROR,
-                            "Exception in callback (" + e.getMessage() + ")",
-                            myParser.getLastLine());
-                    ei.setException(e);
-                    callErrorInfo(ei);
-                }
-            }
-        }
-    }
-
-    /**
-     * Replaces all null entries in the specified array with fake values, if the
-     * corresponding parameter of this callback's type is marked with the
-     * {@link FakableArgument} annotation. The fake classes are constructed by
-     * using parameters designated {@link FakableSource}.
-     *
-     * @param args The arguments to be faked
-     */
-    protected void createFakeArgs(final Object[] args) {
-        int i = 0;
-
-        for (Annotation[] anns : type.getMethods()[0].getParameterAnnotations()) {
-            for (Annotation ann : anns) {
-                if (ann.annotationType().equals(FakableArgument.class) && args[i] == null) {
-                    args[i] = getFakeArg(args, type.getMethods()[0].getParameterTypes()[i]);
-                }
-            }
-
-            i++;
-        }
-    }
-
-    /**
-     * Tries to create fake argument of the specified target class, by using
-     * {@link FakableSource} denoted parameters from the specified arg array.
-     *
-     * If an argument is missing, the method attempts to create a fake instance
-     * by recursing into this method again. Note that this could cause an
-     * infinite recursion in cases of cyclic dependencies. If recursion fails,
-     * the constructor is skipped.
-     *
-     * If the created object has a <code>setFake(boolean)</code> method, it is
-     * automatically invoked with an argument of <code>true</code>.
-     *
-     * @param args The arguments array to use for sources
-     * @param target The class that should be constructed
-     * @return An instance of the target class, or null on failure
-     */
-    protected Object getFakeArg(final Object[] args, final Class<?> target) {
-        final Map<Class<?>, Object> sources = new HashMap<>();
-        int i = 0;
-
-        for (Annotation[] anns : type.getMethods()[0].getParameterAnnotations()) {
-            for (Annotation ann : anns) {
-                if (ann.annotationType().equals(FakableSource.class)) {
-                    final Class<?> argType = type.getMethods()[0].getParameterTypes()[i];
-
-                    sources.put(argType, args[i]);
-                }
-            }
-
-            i++;
-        }
-
-        final Class<?> actualTarget = getImplementation(target);
-
-        for (Constructor<?> ctor : actualTarget.getConstructors()) {
-            final Object[] params = new Object[ctor.getParameterTypes().length];
-
-            i = 0;
-            Object param;
-            boolean failed = false;
-
-            for (Class<?> needed : ctor.getParameterTypes()) {
-                boolean found = false;
-
-                for (Map.Entry<Class<?>, Object> entry : sources.entrySet()) {
-                    if (entry.getKey().isAssignableFrom(needed)) {
-                        params[i] = entry.getValue();
-                        found = true;
-                    }
-                }
-
-                if (!found) {
-                    param = getFakeArg(args, needed);
-
-                    if (param == null) {
-                        failed = true;
-                    } else {
-                        params[i] = param;
-                    }
-                }
-
-                i++;
-            }
-
-            if (!failed) {
-                try {
-                    final Object instance = ctor.newInstance(params);
-
-                    for (Method method : actualTarget.getMethods()) {
-                        if (method.getName().equals("setFake")
-                                && method.getParameterTypes().length == 1
-                                && method.getParameterTypes()[0].equals(Boolean.TYPE)) {
-                            method.invoke(instance, true);
-                        }
-                    }
-
-                    return instance;
-                } catch (InstantiationException | IllegalAccessException |
-                        IllegalArgumentException | InvocationTargetException ex) {
-                    // Do nothing
-                }
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * Returns the concrete class which should be instantiated if this callback
-     * object desires an instance of the specified type. Generally, this will
-     * translate the common interfaces to specific parser-dependent
-     * implementations.
-     *
-     * @param type The type to be instantiated
-     * @return A concrete implementation of that type
-     */
-    protected Class<?> getImplementation(final Class<?> type) {
-        return implementationMap.containsKey(type) ? implementationMap.get(type) : type;
-    }
-
-}

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

@@ -1,165 +0,0 @@
-/*
- * Copyright (c) 2006-2015 DMDirc Developers
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-package com.dmdirc.parser.common;
-
-import com.dmdirc.parser.interfaces.ChannelInfo;
-import com.dmdirc.parser.interfaces.ClientInfo;
-import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.interfaces.SpecificCallback;
-import com.dmdirc.parser.interfaces.callbacks.CallbackInterface;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Superclass for all callback types that have a "specific" target.
- */
-public class CallbackObjectSpecific extends CallbackObject {
-
-    /** Hashtable for storing specific information for callback. */
-    protected final Map<CallbackInterface, String> specificData
-            = new HashMap<>();
-
-    /**
-     * Create a new instance of the Callback Object.
-     *
-     * @param parser Parser That owns this callback
-     * @param manager CallbackManager that is in charge of this callback
-     * @param type The type of callback to use
-     * @param implementationMap A map of interfaces to their parser-specific
-     * @since 0.6.3m1
-     */
-    public CallbackObjectSpecific(final Parser parser, final CallbackManager manager,
-            final Class<? extends CallbackInterface> type,
-            final Map<Class<?>, Class<?>> implementationMap) {
-        super(parser, manager, type, implementationMap);
-    }
-
-    /**
-     * Used to check if a channel matches the specificData.
-     *
-     * @param eMethod Object that is being called back to
-     * @param cChannel ChannelInfo object for the channel to test
-     * @return true if channel given matches the specifics for the method given
-     */
-    protected boolean isValidChan(final CallbackInterface eMethod, final ChannelInfo cChannel) {
-        return !(specificData.containsKey(eMethod) && !myParser
-                .getStringConverter().equalsIgnoreCase(cChannel.getName(),
-                specificData.get(eMethod)));
-    }
-
-    /**
-     * Used to check if a hostname matches the specificData.
-     *
-     * @param eMethod Object that is being called back to
-     * @param sHost Hostname of user that sent the query
-     * @return true if host given matches the specifics for the method given
-     */
-    protected boolean isValidUser(final CallbackInterface eMethod, final String sHost) {
-        final String nickname = translateHostname(sHost);
-        return !(specificData.containsKey(eMethod) && !myParser
-                .getStringConverter().equalsIgnoreCase(nickname,
-                specificData.get(eMethod)));
-    }
-
-    /**
-     * Translates the specified hostname into the form which is used to
-     * register specific callbacks (e.g. nickname).
-     *
-     * @param hostname The hostname to be parsed
-     * @return The translated hostname
-     */
-    protected String translateHostname(final String hostname) {
-        return myParser.parseHostmask(hostname)[0];
-    }
-
-    // We override the default add method to make sure that any add with no
-    // specifics will have the specific data removed.
-    /**
-     * Add a new callback.
-     *
-     * @param eMethod Object to callback to.
-     */
-    @Override
-    public void add(final CallbackInterface eMethod) {
-        addCallback(eMethod);
-        if (specificData.containsKey(eMethod)) {
-            specificData.remove(eMethod);
-        }
-    }
-
-    /**
-     * Add a new callback with a specific target.
-     *
-     * @param eMethod Object to callback to.
-     * @param specificTarget Target that must match for callback to be called.
-     */
-    public void add(final CallbackInterface eMethod, final String specificTarget) {
-        add(eMethod);
-        if (!specificTarget.isEmpty()) {
-            specificData.put(eMethod, specificTarget);
-        }
-    }
-
-    /**
-     * Remove a callback.
-     *
-     * @param eMethod Object to remove callback to.
-     */
-    @Override
-    public void del(final CallbackInterface eMethod) {
-        delCallback(eMethod);
-        if (specificData.containsKey(eMethod)) {
-            specificData.remove(eMethod);
-        }
-    }
-
-    @Override
-    public void call(final Object... args) {
-        createFakeArgs(args);
-
-        for (CallbackInterface iface : new ArrayList<>(callbackInfo)) {
-            if (type.isAnnotationPresent(SpecificCallback.class)
-                    && (args[2] instanceof ClientInfo
-                    && !isValidUser(iface, ((ClientInfo) args[2]).getHostname())
-                    || args[2] instanceof ChannelInfo
-                    && !isValidChan(iface, (ChannelInfo) args[2])
-                    || !(args[2] instanceof ClientInfo
-                    || args[2] instanceof ChannelInfo)
-                    && args[args.length - 1] instanceof String
-                    && !isValidUser(iface, (String) args[args.length - 1]))) {
-                continue;
-            }
-
-            try {
-                type.getMethods()[0].invoke(iface, args);
-            } catch (ReflectiveOperationException e) {
-                final ParserError ei = new ParserError(ParserError.ERROR_ERROR,
-                        "Exception in callback (" + e.getMessage() + ')',
-                        myParser.getLastLine());
-                ei.setException(e);
-                callErrorInfo(ei);
-            }
-        }
-    }
-}

common/src/com/dmdirc/parser/events/ParserErrorEvent.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.events;
+
+import com.dmdirc.parser.common.ParserError;
+import com.dmdirc.parser.interfaces.Parser;
+
+import java.util.Date;
+
+/**
+ * Parser error event.
+ */
+public class ParserErrorEvent extends ParserEvent {
+
+    private final ParserError parserError;
+
+    public ParserErrorEvent(final Parser parser, final Date date, final ParserError parserError) {
+        super(parser, date);
+        this.parserError = parserError;
+    }
+
+    public ParserError getParserError() {
+        return parserError;
+    }
+}

common/src/com/dmdirc/parser/events/ParserEvent.java

@@ -31,8 +31,8 @@ import java.util.Date;
  */
 public class ParserEvent {
 
-    private final Parser parser;
-    private final Date date;
+    private Parser parser;
+    private Date date;
 
     public ParserEvent(final Parser parser, final Date date) {
         this.parser = parser;
@@ -46,4 +46,14 @@ public class ParserEvent {
     public Date getDate() {
         return date;
     }
+
+    // TODO: HACKY REMOVE
+    public void setParser(final Parser parser) {
+        this.parser = parser;
+    }
+
+    // TODO: HACKY REMOVE
+    public void setDate(final Date date) {
+        this.date = date;
+    }
 }