Add timestamps to some events that should have them. Fixes DMDirc/DMDirc#795

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

 import com.dmdirc.parser.irc.ModeManager;
 import com.dmdirc.parser.irc.PrefixModeManager;
 import com.dmdirc.parser.irc.ProcessorNotFoundException;
+import com.dmdirc.parser.irc.TimestampedIRCProcessor;
 import com.dmdirc.parser.irc.events.IRCDataOutEvent;
 import net.engio.mbassy.listener.Handler;
 
 /**
  * Process a channel join.
  */
-public class ProcessJoin extends IRCProcessor {
+public class ProcessJoin extends TimestampedIRCProcessor {
 
     /** The manager to use to access prefix modes. */
     private final PrefixModeManager prefixModeManager;
     /**
      * Process a channel join.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process ("JOIN")
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
         callDebugInfo(IRCParser.DEBUG_INFO, "processJoin: %s | %s", sParam, Arrays.toString(token));
 
         if ("329".equals(sParam)) {
                     // joined.
                     callDebugInfo(IRCParser.DEBUG_INFO, "processJoin: Adding client to channel.");
                     final IRCChannelClientInfo iChannelClient = iChannel.addClient(iClient);
-                    callChannelJoin(iChannel, iChannelClient);
+                    callChannelJoin(date, iChannel, iChannelClient);
                     callDebugInfo(IRCParser.DEBUG_INFO, "processJoin: Added client to channel.");
                     return;
                 } else {
                 pendingJoins.clear();
             }
 
-            callChannelSelfJoin(iChannel);
+            callChannelSelfJoin(date, iChannel);
         } else {
             // Some kind of failed to join, pop the pending join queues.
             final PendingJoin pendingJoin = pendingJoins.poll();
     /**
      * Callback to all objects implementing the ChannelJoin Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel Object
      * @param cChannelClient ChannelClient object for new person
      */
-    protected void callChannelJoin(final ChannelInfo cChannel,
+    protected void callChannelJoin(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient) {
         getCallbackManager().publish(
-                new ChannelJoinEvent(parser, LocalDateTime.now(), cChannel, cChannelClient));
+                new ChannelJoinEvent(parser, date, cChannel, cChannelClient));
     }
 
     /**
      * Callback to all objects implementing the ChannelSelfJoin Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel Object
      */
-    protected void callChannelSelfJoin(final ChannelInfo cChannel) {
+    protected void callChannelSelfJoin(final LocalDateTime date, final ChannelInfo cChannel) {
         getCallbackManager().publish(new ChannelSelfJoinEvent(
-                parser, LocalDateTime.now(), cChannel));
+                parser, date, cChannel));
     }
 
 

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

 import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.IRCClientInfo;
 import com.dmdirc.parser.irc.IRCParser;
+import com.dmdirc.parser.irc.TimestampedIRCProcessor;
 
 import java.time.LocalDateTime;
 import java.util.Arrays;
 /**
  * Process a channel kick.
  */
-public class ProcessKick extends IRCProcessor {
+public class ProcessKick extends TimestampedIRCProcessor {
 
     /**
      * Create a new instance of the IRCProcessor Object.
     /**
      * Process a channel kick.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process ("KICK")
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
         callDebugInfo(IRCParser.DEBUG_INFO, "processKick: %s | %s", sParam, Arrays.toString(token));
 
         final IRCClientInfo iClient = getClientInfo(token[3]);
             final IRCChannelClientInfo iChannelKicker = iChannel.getChannelClient(token[0], true);
             if (parser.getRemoveAfterCallback()) {
                 callDebugInfo(IRCParser.DEBUG_INFO, "processKick: calling kick before. {%s | %s | %s | %s | %s}", iChannel, iChannelClient, iChannelKicker, sReason, token[0]);
-                callChannelKick(iChannel, iChannelClient, iChannelKicker, sReason, token[0]);
+                callChannelKick(date, iChannel, iChannelClient, iChannelKicker, sReason, token[0]);
             }
             callDebugInfo(IRCParser.DEBUG_INFO, "processKick: removing client from channel { %s | %s }", iChannel, iClient);
             iChannel.delClient(iClient);
             callDebugInfo(IRCParser.DEBUG_INFO, "processKick: removed client from channel { %s | %s }", iChannel, iClient);
             if (!parser.getRemoveAfterCallback()) {
                 callDebugInfo(IRCParser.DEBUG_INFO, "processKick: calling kick after. {%s | %s | %s | %s | %s}", iChannel, iChannelClient, iChannelKicker, sReason, token[0]);
-                callChannelKick(iChannel, iChannelClient, iChannelKicker, sReason, token[0]);
+                callChannelKick(date, iChannel, iChannelClient, iChannelKicker, sReason, token[0]);
             }
             if (iClient == parser.getLocalClient()) {
                 iChannel.emptyChannel();
     /**
      * Callback to all objects implementing the ChannelKick Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel where the kick took place
      * @param cKickedClient ChannelClient that got kicked
      * @param cKickedByClient ChannelClient that did the kicking
      * @param sReason Reason for kick (may be "")
      * @param sKickedByHost Hostname of Kicker (or servername)
      */
-    protected void callChannelKick(final ChannelInfo cChannel,
+    protected void callChannelKick(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cKickedClient, final ChannelClientInfo cKickedByClient,
             final String sReason, final String sKickedByHost) {
         getCallbackManager().publish(
-                new ChannelKickEvent(parser, LocalDateTime.now(), cChannel, cKickedClient,
+                new ChannelKickEvent(parser, date, cChannel, cKickedClient,
                         cKickedByClient, sReason, sKickedByHost));
     }
 

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

 import com.dmdirc.parser.irc.IRCParser;
 import com.dmdirc.parser.irc.ServerType;
 import com.dmdirc.parser.irc.ServerTypeGroup;
+import com.dmdirc.parser.irc.TimestampedIRCProcessor;
 
 import java.time.LocalDateTime;
 import java.util.Arrays;
 /**
  * Process a List Modes.
  */
-public class ProcessListModes extends IRCProcessor {
+public class ProcessListModes extends TimestampedIRCProcessor {
 
     /**
      * Create a new instance of the IRCProcessor Object.
     /**
      * Process a ListModes.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
         final IRCChannelInfo channel = getChannel(token[3]);
         final ServerType serverType = parser.getServerType();
         if (channel == null) {
                             .stream()
                             .filter(thisMode -> parser.chanModesOther
                                     .get(thisMode) == IRCParser.MODE_LIST)
-                            .forEach(thisMode -> callChannelGotListModes(channel, thisMode));
+                            .forEach(thisMode -> callChannelGotListModes(date, channel, thisMode));
                 } else {
-                    callChannelGotListModes(channel, mode);
+                    callChannelGotListModes(date, channel, mode);
                 }
             }
         }
     /**
      * Callback to all objects implementing the ChannelGotListModes Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel which the ListModes reply is for
      * @param mode the mode that we got list modes for.
      */
-    protected void callChannelGotListModes(final ChannelInfo cChannel, final char mode) {
-        getCallbackManager().publish(new ChannelListModeEvent(parser, LocalDateTime.now(), cChannel,
+    protected void callChannelGotListModes(final LocalDateTime date, final ChannelInfo cChannel, final char mode) {
+        getCallbackManager().publish(new ChannelListModeEvent(parser, date, cChannel,
                 mode));
     }
 }

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

      * Actions are handled here aswell separately from CTCPs.<br>
      * Each type has 5 Calls, making 15 callbacks handled here.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process ("NOTICE", "PRIVMSG")
      * @param token IRCTokenised line to process
      */

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

 import com.dmdirc.parser.irc.IRCParser;
 import com.dmdirc.parser.irc.ModeManager;
 import com.dmdirc.parser.irc.PrefixModeManager;
+import com.dmdirc.parser.irc.TimestampedIRCProcessor;
 
 import java.time.LocalDateTime;
 import java.util.Calendar;
 /**
  * Process a Mode line.
  */
-public class ProcessMode extends IRCProcessor {
+public class ProcessMode extends TimestampedIRCProcessor {
 
     /** The manager to use to access prefix modes. */
     private final PrefixModeManager prefixModeManager;
     /**
      * Process a Mode Line.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process ("MODE", "324")
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
         final String[] sModestr;
         final String sChannelName;
         switch (sParam) {
                 System.arraycopy(token, 4, sModestr, 0, token.length - 4);
                 break;
             case "221":
-                processUserMode(sParam, token, new String[]{token[token.length - 1]}, true);
+                processUserMode(date, sParam, token, new String[]{token[token.length - 1]}, true);
                 return;
             default:
                 sChannelName = token[2];
         }
 
         if (isValidChannelName(sChannelName)) {
-            processChanMode(sParam, token, sModestr, sChannelName);
+            processChanMode(date, sParam, token, sModestr, sChannelName);
         } else {
-            processUserMode(sParam, token, sModestr, false);
+            processUserMode(date, sParam, token, sModestr, false);
         }
     }
 
     /**
      * Process Chan modes.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam String representation of parameter to parse
      * @param token IRCTokenised Array of the incomming line
      * @param sModestr The modes and params
      * @param sChannelName Channel these modes are for
      */
-    public void processChanMode(final String sParam, final String[] token, final String[] sModestr, final String sChannelName) {
+    public void processChanMode(final LocalDateTime date, final String sParam, final String[] token, final String[] sModestr, final String sChannelName) {
         final StringBuilder sFullModeStr = new StringBuilder();
 
         final IRCChannelInfo iChannel = getChannel(sChannelName);
                     } else {
                         iChannelClientInfo.removeMode(cMode);
                     }
-                    callChannelUserModeChanged(iChannel, iChannelClientInfo, setterCCI, token[0],
+                    callChannelUserModeChanged(date, iChannel, iChannelClientInfo, setterCCI, token[0],
                             (bPositive ? "+" : "-") + cMode);
                     continue;
                 } else {
 
         iChannel.setMode(nCurrent);
         if ("324".equals(sParam)) {
-            callChannelModeChanged(iChannel, setterCCI, "", sFullModeStr.toString().trim());
+            callChannelModeChanged(date, iChannel, setterCCI, "", sFullModeStr.toString().trim());
         } else {
-            callChannelModeChanged(iChannel, setterCCI, token[0], sFullModeStr.toString().trim());
+            callChannelModeChanged(date, iChannel, setterCCI, token[0], sFullModeStr.toString().trim());
             getCallbackManager().publish(
                     new ChannelNonUserModeChangeEvent(parser, LocalDateTime.now(), iChannel,
                             setterCCI, token[0],
     /**
      * Process user modes.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam String representation of parameter to parse
      * @param token IRCTokenised Array of the incomming line
      * @param clearOldModes Clear old modes before applying these modes (used by 221)
      */
-    private void processUserMode(final String sParam, final String[] token, final String[] sModestr,
+    private void processUserMode(final LocalDateTime date, final String sParam, final String[] token, final String[] sModestr,
             final boolean clearOldModes) {
         final IRCClientInfo iClient = getClientInfo(token[2]);
 
 
         iClient.setUserMode(nCurrent);
         if ("221".equals(sParam)) {
-            callUserModeDiscovered(iClient, sModestr[0]);
+            callUserModeDiscovered(date, iClient, sModestr[0]);
         } else {
-            callUserModeChanged(iClient, token[0], sModestr[0]);
+            callUserModeChanged(date, iClient, token[0], sModestr[0]);
         }
     }
 
     /**
      * Callback to all objects implementing the ChannelModeChanged Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel where modes were changed
      * @param cChannelClient Client chaning the modes (null if server)
      * @param sHost Host doing the mode changing (User host or server name)
      * @param sModes Exact String parsed
      */
-    protected void callChannelModeChanged(final ChannelInfo cChannel,
+    protected void callChannelModeChanged(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sHost, final String sModes) {
         getCallbackManager().publish(
-                new ChannelModeChangeEvent(parser, LocalDateTime.now(), cChannel, cChannelClient,
+                new ChannelModeChangeEvent(parser, date, cChannel, cChannelClient,
                         sHost, sModes));
     }
 
     /**
      * Callback to all objects implementing the ChannelUserModeChanged Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel where modes were changed
      * @param cChangedClient Client being changed
      * @param cSetByClient Client chaning the modes (null if server)
      * @param sHost Host doing the mode changing (User host or server name)
      * @param sMode String representing mode change (ie +o)
      */
-    protected void callChannelUserModeChanged(final ChannelInfo cChannel,
+    protected void callChannelUserModeChanged(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cChangedClient, final ChannelClientInfo cSetByClient,
             final String sHost, final String sMode) {
         getCallbackManager().publish(
-                new ChannelUserModeChangeEvent(parser, LocalDateTime.now(), cChannel,
+                new ChannelUserModeChangeEvent(parser, date, cChannel,
                         cChangedClient, cSetByClient, sHost, sMode));
     }
 
     /**
      * Callback to all objects implementing the UserModeChanged Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cClient Client that had the mode changed (almost always us)
      * @param sSetby Host that set the mode (us or servername)
      * @param sModes The modes set.
      */
-    protected void callUserModeChanged(final ClientInfo cClient, final String sSetby,
+    protected void callUserModeChanged(final LocalDateTime date, final ClientInfo cClient, final String sSetby,
             final String sModes) {
         getCallbackManager().publish(
-                new UserModeChangeEvent(parser, LocalDateTime.now(), cClient, sSetby, sModes));
+                new UserModeChangeEvent(parser, date, cClient, sSetby, sModes));
     }
 
     /**
      * Callback to all objects implementing the UserModeDiscovered Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cClient Client that had the mode changed (almost always us)
      * @param sModes The modes set.
      */
-    protected void callUserModeDiscovered(final ClientInfo cClient, final String sModes) {
+    protected void callUserModeDiscovered(final LocalDateTime date, final ClientInfo cClient, final String sModes) {
         getCallbackManager().publish(
-                new UserModeDiscoveryEvent(parser, LocalDateTime.now(), cClient, sModes));
+                new UserModeDiscoveryEvent(parser, date, cClient, sModes));
     }
 
 }

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

 import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.IRCClientInfo;
 import com.dmdirc.parser.irc.IRCParser;
+import com.dmdirc.parser.irc.TimestampedIRCProcessor;
 
 import java.time.LocalDateTime;
 
 /**
  * Process a Nick change.
  */
-public class ProcessNick extends IRCProcessor {
+public class ProcessNick extends TimestampedIRCProcessor {
 
     /**
      * Create a new instance of the IRCProcessor Object.
     /**
      * Process a Nick change.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process ("NICK")
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
 
         final IRCClientInfo iClient = getClientInfo(token[0]);
         if (iClient == null) {
                     if (!isSameNick) {
                         iChannel.renameClient(oldNickname, iChannelClient);
                     }
-                    callChannelNickChanged(iChannel, iChannelClient, IRCClientInfo.parseHost(token[0]));
+                    callChannelNickChanged(date, iChannel, iChannelClient, IRCClientInfo.parseHost(token[0]));
                 }
             }
 
-            callNickChanged(iClient, IRCClientInfo.parseHost(token[0]));
+            callNickChanged(date, iClient, IRCClientInfo.parseHost(token[0]));
         }
     }
 
     /**
      * Callback to all objects implementing the ChannelNickChanged Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel One of the channels that the user is on
      * @param cChannelClient Client changing nickname
      * @param sOldNick Nickname before change
      */
-    protected void callChannelNickChanged(final ChannelInfo cChannel,
+    protected void callChannelNickChanged(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sOldNick) {
         getCallbackManager().publish(
-                new ChannelNickChangeEvent(parser, LocalDateTime.now(), cChannel, cChannelClient,
+                new ChannelNickChangeEvent(parser, date, cChannel, cChannelClient,
                         sOldNick));
     }
 
     /**
      * Callback to all objects implementing the NickChanged Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cClient Client changing nickname
      * @param sOldNick Nickname before change
      */
-    protected void callNickChanged(final ClientInfo cClient, final String sOldNick) {
-        getCallbackManager().publish(new NickChangeEvent(parser, LocalDateTime.now(), cClient,
+    protected void callNickChanged(final LocalDateTime date, final ClientInfo cClient, final String sOldNick) {
+        getCallbackManager().publish(new NickChangeEvent(parser, date, cClient,
                 sOldNick));
     }
 

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

 import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.IRCClientInfo;
 import com.dmdirc.parser.irc.IRCParser;
+import com.dmdirc.parser.irc.TimestampedIRCProcessor;
 
 import java.time.LocalDateTime;
 
 /**
  * Process a channel part.
  */
-public class ProcessPart extends IRCProcessor {
+public class ProcessPart extends TimestampedIRCProcessor {
 
     /**
      * Create a new instance of the IRCProcessor Object.
     /**
      * Process a channel part.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process ("PART")
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
         // :nick!ident@host PART #Channel
         // :nick!ident@host PART #Channel :reason
         if (token.length < 3) {
                 return;
             }
             if (parser.getRemoveAfterCallback()) {
-                callChannelPart(iChannel, iChannelClient, sReason);
+                callChannelPart(date, iChannel, iChannelClient, sReason);
             }
             callDebugInfo(IRCParser.DEBUG_INFO, "Removing %s from %s", iClient.getNickname(), iChannel.getName());
             iChannel.delClient(iClient);
             if (!parser.getRemoveAfterCallback()) {
-                callChannelPart(iChannel, iChannelClient, sReason);
+                callChannelPart(date, iChannel, iChannelClient, sReason);
             }
             if (iClient == parser.getLocalClient()) {
                 iChannel.emptyChannel();
     /**
      * Callback to all objects implementing the ChannelPart Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel that the user parted
      * @param cChannelClient Client that parted
      * @param sReason Reason given for parting (May be "")
      */
-    protected void callChannelPart(final ChannelInfo cChannel,
+    protected void callChannelPart(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sReason) {
         getCallbackManager().publish(
-                new ChannelPartEvent(parser, LocalDateTime.now(), cChannel, cChannelClient,
+                new ChannelPartEvent(parser, date, cChannel, cChannelClient,
                         sReason));
     }
 

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

 import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.IRCClientInfo;
 import com.dmdirc.parser.irc.IRCParser;
+import com.dmdirc.parser.irc.TimestampedIRCProcessor;
 
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 /**
  * Process a Quit message.
  */
-public class ProcessQuit extends IRCProcessor {
+public class ProcessQuit extends TimestampedIRCProcessor {
 
     /**
      * Create a new instance of the IRCProcessor Object.
     /**
      * Process a Quit message.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process ("QUIT")
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
         // :nick!ident@host QUIT
         // :nick!ident@host QUIT :reason
         if (token.length < 2) {
             final IRCChannelClientInfo iChannelClient = iChannel.getChannelClient(iClient);
             if (iChannelClient != null) {
                 if (parser.getRemoveAfterCallback()) {
-                    callChannelQuit(iChannel, iChannelClient, sReason);
+                    callChannelQuit(date, iChannel, iChannelClient, sReason);
                 }
                 if (iClient == parser.getLocalClient()) {
                     iChannel.emptyChannel();
                     iChannel.delClient(iClient);
                 }
                 if (!parser.getRemoveAfterCallback()) {
-                    callChannelQuit(iChannel, iChannelClient, sReason);
+                    callChannelQuit(date, iChannel, iChannelClient, sReason);
                 }
             }
         }
 
         if (parser.getRemoveAfterCallback()) {
-            callQuit(iClient, sReason);
+            callQuit(date, iClient, sReason);
         }
         if (iClient == parser.getLocalClient()) {
             parser.clearClients();
             parser.removeClient(iClient);
         }
         if (!parser.getRemoveAfterCallback()) {
-            callQuit(iClient, sReason);
+            callQuit(date, iClient, sReason);
         }
     }
 
     /**
      * Callback to all objects implementing the ChannelQuit Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel that user was on
      * @param cChannelClient User thats quitting
      * @param sReason Quit reason
      */
-    protected void callChannelQuit(final ChannelInfo cChannel,
+    protected void callChannelQuit(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sReason) {
         getCallbackManager().publish(
                 new ChannelQuitEvent(parser, LocalDateTime.now(), cChannel, cChannelClient,
     /**
      * Callback to all objects implementing the Quit Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cClient Client Quitting
      * @param sReason Reason for quitting (may be "")
      */
-    protected void callQuit(final ClientInfo cClient, final String sReason) {
-        getCallbackManager().publish(new QuitEvent(parser, LocalDateTime.now(), cClient, sReason));
+    protected void callQuit(final LocalDateTime date, final ClientInfo cClient, final String sReason) {
+        getCallbackManager().publish(new QuitEvent(parser, date, cClient, sReason));
     }
 
 }

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

 import com.dmdirc.parser.irc.IRCChannelInfo;
 import com.dmdirc.parser.irc.IRCClientInfo;
 import com.dmdirc.parser.irc.IRCParser;
+import com.dmdirc.parser.irc.TimestampedIRCProcessor;
 
 import java.time.LocalDateTime;
 
 /**
  * Process a topic change.
  */
-public class ProcessTopic extends IRCProcessor {
+public class ProcessTopic extends TimestampedIRCProcessor {
 
     /**
      * Create a new instance of the IRCProcessor Object.
     /**
      * Process a topic change.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process ("TOPIC", "332", "333")
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
         final IRCChannelInfo iChannel;
         switch (sParam) {
             case "332":
                             iChannel.setTopicTime(Long.parseLong(token[5]));
                         }
                     }
-                    callChannelTopic(iChannel, true);
+                    callChannelTopic(date, iChannel, true);
                 }   break;
             default:
                 if (IRCParser.ALWAYS_UPDATECLIENT) {
                 iChannel.setTopicTime(System.currentTimeMillis() / 1000);
                 iChannel.setTopicUser(token[0].charAt(0) == ':' ? token[0].substring(1) : token[0]);
                 iChannel.setInternalTopic(token[token.length - 1]);
-                callChannelTopic(iChannel, false);
+                callChannelTopic(date, iChannel, false);
                 break;
         }
     }
     /**
      * Callback to all objects implementing the ChannelTopic Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel that topic was set on
      * @param bIsJoinTopic True when getting topic on join, false if set by user/server
      */
-    protected void callChannelTopic(final ChannelInfo cChannel, final boolean bIsJoinTopic) {
+    protected void callChannelTopic(final LocalDateTime date, final ChannelInfo cChannel, final boolean bIsJoinTopic) {
         ((IRCChannelInfo) cChannel).setHadTopic();
         getCallbackManager().publish(
-                new ChannelTopicEvent(parser, LocalDateTime.now(), cChannel, bIsJoinTopic));
+                new ChannelTopicEvent(parser, date, cChannel, bIsJoinTopic));
     }
 
 }