Merge pull request #107 from csmith/master

Migrate parser events to use new date APIs.

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

 import java.net.SocketAddress;
 import java.net.URI;
 import java.net.URISyntaxException;
-import java.util.Date;
+import java.time.LocalDateTime;
 import java.util.List;
 
 import net.engio.mbassy.bus.error.PublicationError;
         }
 
         synchronized (errorHandlerLock) {
-            callbackManager.publish(new ParserErrorEvent(this, new Date(), e.getCause()));
+            callbackManager.publish(new ParserErrorEvent(this, LocalDateTime.now(), e.getCause()));
         }
     }
 

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
     private final String message;
 
-    public AuthNoticeEvent(final Parser parser, final Date date, final String message) {
+    public AuthNoticeEvent(final Parser parser, final LocalDateTime date, final String message) {
         super(parser, date);
         this.message = checkNotNull(message);
     }

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

 import com.dmdirc.parser.common.AwayState;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import javax.annotation.Nullable;
 
     private final AwayState newState;
     private final String reason;
 
-    public AwayStateEvent(final Parser parser, final Date date, final AwayState oldState,
+    public AwayStateEvent(final Parser parser, final LocalDateTime date, final AwayState oldState,
             final AwayState newState, @Nullable final String reason) {
         super(parser, date);
         this.oldState = checkNotNull(oldState);

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String message;
     private final String host;
 
-    public ChannelActionEvent(final Parser parser, final Date date, final ChannelInfo channel,
-            final ChannelClientInfo client, final String message, final String host) {
+    public ChannelActionEvent(final Parser parser, final LocalDateTime date,
+            final ChannelInfo channel, final ChannelClientInfo client, final String message,
+            final String host) {
         super(parser, date);
         this.channel = checkNotNull(channel);
         this.client = checkNotNull(client);

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String message;
     private final String host;
 
-    public ChannelCTCPEvent(final Parser parser, final Date date, final ChannelInfo channel,
-            final ChannelClientInfo client, final String type, final String message,
-            final String host) {
+    public ChannelCTCPEvent(final Parser parser, final LocalDateTime date,
+            final ChannelInfo channel, final ChannelClientInfo client, final String type,
+            final String message, final String host) {
         super(parser, date);
         this.channel = checkNotNull(channel);
         this.client = checkNotNull(client);

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String message;
     private final String host;
 
-    public ChannelCTCPReplyEvent(final Parser parser, final Date date, final ChannelInfo channel,
-            final ChannelClientInfo client, final String type, final String message,
-            final String host) {
+    public ChannelCTCPReplyEvent(final Parser parser, final LocalDateTime date,
+            final ChannelInfo channel, final ChannelClientInfo client, final String type,
+            final String message, final String host) {
         super(parser, date);
         this.channel = checkNotNull(channel);
         this.client = checkNotNull(client);

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final ChannelInfo channel;
     private final ChannelClientInfo client;
 
-    public ChannelJoinEvent(final Parser parser, final Date date, final ChannelInfo channel,
-            final ChannelClientInfo client) {
+    public ChannelJoinEvent(final Parser parser, final LocalDateTime date,
+            final ChannelInfo channel, final ChannelClientInfo client) {
         super(parser, date);
         this.channel = checkNotNull(channel);
         this.client = checkNotNull(client);

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String reason;
     private final String host;
 
-    public ChannelKickEvent(final Parser parser, final Date date, final ChannelInfo channel,
+    public ChannelKickEvent(final Parser parser, final LocalDateTime date, final ChannelInfo channel,
             final ChannelClientInfo kickedClient, final ChannelClientInfo client,
             final String reason, final String host) {
         super(parser, date);

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final ChannelInfo channel;
     private final char mode;
 
-    public ChannelListModeEvent(final Parser parser, final Date date, final ChannelInfo channel,
-            final char mode) {
+    public ChannelListModeEvent(final Parser parser, final LocalDateTime date,
+            final ChannelInfo channel, final char mode) {
         super(parser, date);
         this.channel = checkNotNull(channel);
         this.mode = mode;

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String message;
     private final String host;
 
-    public ChannelMessageEvent(final Parser parser, final Date date, final ChannelInfo channel,
-            final ChannelClientInfo client, final String message, final String host) {
+    public ChannelMessageEvent(final Parser parser, final LocalDateTime date,
+            final ChannelInfo channel, final ChannelClientInfo client, final String message,
+            final String host) {
         super(parser, date);
         this.channel = checkNotNull(channel);
         this.client = checkNotNull(client);

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String host;
     private final String modes;
 
-    public ChannelModeChangeEvent(final Parser parser, final Date date, final ChannelInfo channel,
-            final ChannelClientInfo client, final String host, final String modes) {
+    public ChannelModeChangeEvent(final Parser parser, final LocalDateTime date,
+            final ChannelInfo channel, final ChannelClientInfo client, final String host,
+            final String modes) {
         super(parser, date);
         this.channel = checkNotNull(channel);
         this.client = checkNotNull(client);

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String message;
     private final String host;
 
-    public ChannelModeMessageEvent(final Parser parser, final Date date, final ChannelInfo channel,
-            final char prefix, final ChannelClientInfo client, final String message,
-            final String host) {
+    public ChannelModeMessageEvent(final Parser parser, final LocalDateTime date,
+            final ChannelInfo channel, final char prefix, final ChannelClientInfo client,
+            final String message, final String host) {
         super(parser, date);
         this.channel = checkNotNull(channel);
         this.prefix = checkNotNull(prefix);

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String message;
     private final String host;
 
-    public ChannelModeNoticeEvent(final Parser parser, final Date date, final ChannelInfo channel,
-            final char prefix, final ChannelClientInfo client, final String message,
-            final String host) {
+    public ChannelModeNoticeEvent(final Parser parser, final LocalDateTime date,
+            final ChannelInfo channel, final char prefix, final ChannelClientInfo client,
+            final String message, final String host) {
         super(parser, date);
         this.channel = checkNotNull(channel);
         this.prefix = checkNotNull(prefix);

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
     private final ChannelInfo channel;
 
-    public ChannelNamesEvent(final Parser parser, final Date date, final ChannelInfo channel) {
+    public ChannelNamesEvent(final Parser parser, final LocalDateTime date,
+            final ChannelInfo channel) {
         super(parser, date);
         this.channel = checkNotNull(channel);
     }

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final ChannelClientInfo client;
     private final String oldNick;
 
-    public ChannelNickChangeEvent(final Parser parser, final Date date, final ChannelInfo channel,
-            final ChannelClientInfo client, final String oldNick) {
+    public ChannelNickChangeEvent(final Parser parser, final LocalDateTime date,
+            final ChannelInfo channel, final ChannelClientInfo client, final String oldNick) {
         super(parser, date);
         this.channel = checkNotNull(channel);
         this.client = checkNotNull(client);

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String host;
     private final String modes;
 
-    public ChannelNonUserModeChangeEvent(final Parser parser, final Date date,
+    public ChannelNonUserModeChangeEvent(final Parser parser, final LocalDateTime date,
             final ChannelInfo channel, final ChannelClientInfo client, final String host,
             final String modes) {
         super(parser, date);

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String message;
     private final String host;
 
-    public ChannelNoticeEvent(final Parser parser, final Date date, final ChannelInfo channel,
-            final ChannelClientInfo client, final String message, final String host) {
+    public ChannelNoticeEvent(final Parser parser, final LocalDateTime date,
+            final ChannelInfo channel, final ChannelClientInfo client, final String message,
+            final String host) {
         super(parser, date);
         this.channel = checkNotNull(channel);
         this.client = checkNotNull(client);

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final AwayState oldState;
     private final AwayState newState;
 
-    public ChannelOtherAwayStateEvent(final Parser parser, final Date date,
+    public ChannelOtherAwayStateEvent(final Parser parser, final LocalDateTime date,
             final ChannelInfo channel, final ChannelClientInfo client, final AwayState oldState,
             final AwayState newState) {
         super(parser, date);

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final ChannelClientInfo client;
     private final String reason;
 
-    public ChannelPartEvent(final Parser parser, final Date date, final ChannelInfo channel,
-            final ChannelClientInfo client, final String reason) {
+    public ChannelPartEvent(final Parser parser, final LocalDateTime date,
+            final ChannelInfo channel, final ChannelClientInfo client, final String reason) {
         super(parser, date);
         this.channel = checkNotNull(channel);
         this.client = checkNotNull(client);

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final ChannelClientInfo client;
     private final String reason;
 
-    public ChannelQuitEvent(final Parser parser, final Date date, final ChannelInfo channel,
-            final ChannelClientInfo client, final String reason) {
+    public ChannelQuitEvent(final Parser parser, final LocalDateTime date,
+            final ChannelInfo channel, final ChannelClientInfo client, final String reason) {
         super(parser, date);
         this.channel = checkNotNull(channel);
         this.client = checkNotNull(client);

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
     private final ChannelInfo channel;
 
-    public ChannelSelfJoinEvent(final Parser parser, final Date date, final ChannelInfo channel) {
+    public ChannelSelfJoinEvent(final Parser parser, final LocalDateTime date,
+            final ChannelInfo channel) {
         super(parser, date);
         this.channel = checkNotNull(channel);
     }

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String host;
     private final String modes;
 
-    public ChannelSingleModeChangeEvent(final Parser parser, final Date date,
+    public ChannelSingleModeChangeEvent(final Parser parser, final LocalDateTime date,
             final ChannelInfo channel, final ChannelClientInfo client, final String host,
             final String modes) {
         super(parser, date);

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final ChannelInfo channel;
     private final boolean isJoinTopic;
 
-    public ChannelTopicEvent(final Parser parser, final Date date, final ChannelInfo channel,
-            final boolean isJoinTopic) {
+    public ChannelTopicEvent(final Parser parser, final LocalDateTime date,
+            final ChannelInfo channel, final boolean isJoinTopic) {
         super(parser, date);
         this.channel = checkNotNull(channel);
         this.isJoinTopic = isJoinTopic;

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

 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String host;
     private final String mode;
 
-    public ChannelUserModeChangeEvent(final Parser parser, final Date date,
+    public ChannelUserModeChangeEvent(final Parser parser, final LocalDateTime date,
             final ChannelInfo channel, final ChannelClientInfo targetClient,
             final ChannelClientInfo client, final String host, final String mode) {
         super(parser, date);

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

 import com.dmdirc.parser.common.CompositionState;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final CompositionState state;
     private final String host;
 
-    public CompositionStateChangeEvent(final Parser parser, final Date date,
+    public CompositionStateChangeEvent(final Parser parser, final LocalDateTime date,
             final CompositionState state, final String host) {
         super(parser, date);
         this.state = checkNotNull(state);

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

 import com.dmdirc.parser.common.ParserError;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
     private final ParserError errorInfo;
 
-    public ConnectErrorEvent(final Parser parser, final Date date, final ParserError errorInfo) {
+    public ConnectErrorEvent(final Parser parser, final LocalDateTime date,
+            final ParserError errorInfo) {
         super(parser, date);
         this.errorInfo = checkNotNull(errorInfo);
     }

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
     private final String data;
 
-    public DataInEvent(final Parser parser, final Date date, final String data) {
+    public DataInEvent(final Parser parser, final LocalDateTime date, final String data) {
         super(parser, date);
         this.data = checkNotNull(data);
     }

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
     private final String data;
 
-    public DataOutEvent(final Parser parser, final Date date, final String data) {
+    public DataOutEvent(final Parser parser, final LocalDateTime date, final String data) {
         super(parser, date);
         this.data = checkNotNull(data);
     }

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final int level;
     private final String data;
 
-    public DebugInfoEvent(final Parser parser, final Date date, final int level,
+    public DebugInfoEvent(final Parser parser, final LocalDateTime date, final int level,
             final String data) {
         super(parser, date);
         this.level = level;

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

 import com.dmdirc.parser.common.ParserError;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
     private final ParserError errorInfo;
 
-    public ErrorInfoEvent(final Parser parser, final Date date, final ParserError errorInfo) {
+    public ErrorInfoEvent(final Parser parser, final LocalDateTime date,
+            final ParserError errorInfo) {
         super(parser, date);
         this.errorInfo = checkNotNull(errorInfo);
     }

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 /**
  * Callback interface for when the parser receives the end of a group list response.
  */
 public class GroupListEndEvent extends ParserEvent {
 
-    public GroupListEndEvent(final Parser parser, final Date date) {
+    public GroupListEndEvent(final Parser parser, final LocalDateTime date) {
         super(parser, date);
     }
 }

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final int users;
     private final String topic;
 
-    public GroupListEntryEvent(final Parser parser, final Date date, final String name,
+    public GroupListEntryEvent(final Parser parser, final LocalDateTime date, final String name,
             final int users, final String topic) {
         super(parser, date);
         this.name = checkNotNull(name);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 /**
  * Callback interface for when the parser receives the start of a group list response.
  */
 public class GroupListStartEvent extends ParserEvent {
 
-    public GroupListStartEvent(final Parser parser, final Date date) {
+    public GroupListStartEvent(final Parser parser, final LocalDateTime date) {
         super(parser, date);
     }
 }

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String userHost;
     private final String channel;
 
-    public InviteEvent(final Parser parser, final Date date, final String userHost,
+    public InviteEvent(final Parser parser, final LocalDateTime date, final String userHost,
             final String channel) {
         super(parser, date);
         this.userHost = checkNotNull(userHost);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final boolean noMOTD;
     private final String data;
 
-    public MOTDEndEvent(final Parser parser, final Date date, final boolean noMOTD,
+    public MOTDEndEvent(final Parser parser, final LocalDateTime date, final boolean noMOTD,
             final String data) {
         super(parser, date);
         this.noMOTD = noMOTD;

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
     private final String data;
 
-    public MOTDLineEvent(final Parser parser, final Date date, final String data) {
+    public MOTDLineEvent(final Parser parser, final LocalDateTime date, final String data) {
         super(parser, date);
         this.data = checkNotNull(data);
     }

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
     private final String data;
 
-    public MOTDStartEvent(final Parser parser, final Date date, final String data) {
+    public MOTDStartEvent(final Parser parser, final LocalDateTime date, final String data) {
         super(parser, date);
         this.data = checkNotNull(data);
     }

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String ircdVersion;
     private final String ircdType;
 
-    public NetworkDetectedEvent(final Parser parser, final Date date, final String networkName,
-            final String ircdVersion, final String ircdType) {
+    public NetworkDetectedEvent(final Parser parser, final LocalDateTime date,
+            final String networkName, final String ircdVersion, final String ircdType) {
         super(parser, date);
         this.networkName = checkNotNull(networkName);
         this.ircdVersion = checkNotNull(ircdVersion);

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

 import com.dmdirc.parser.interfaces.ClientInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final ClientInfo client;
     private final String oldNick;
 
-    public NickChangeEvent(final Parser parser, final Date date, final ClientInfo client,
+    public NickChangeEvent(final Parser parser, final LocalDateTime date, final ClientInfo client,
             final String oldNick) {
         super(parser, date);
         this.client = checkNotNull(client);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
     private final String nickname;
 
-    public NickInUseEvent(final Parser parser, final Date date, final String nickname) {
+    public NickInUseEvent(final Parser parser, final LocalDateTime date, final String nickname) {
         super(parser, date);
         this.nickname = checkNotNull(nickname);
     }

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final int numeric;
     private final String[] token;
 
-    public NumericEvent(final Parser parser, final Date date, final int numeric,
+    public NumericEvent(final Parser parser, final LocalDateTime date, final int numeric,
             final String[] token) {
         super(parser, date);
         this.numeric = checkNotNull(numeric);

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

 import com.dmdirc.parser.interfaces.ClientInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final AwayState oldState;
     private final AwayState newState;
 
-    public OtherAwayStateEvent(final Parser parser, final Date date, final ClientInfo client,
-            final AwayState oldState, final AwayState newState) {
+    public OtherAwayStateEvent(final Parser parser, final LocalDateTime date,
+            final ClientInfo client, final AwayState oldState, final AwayState newState) {
         super(parser, date);
         this.client = checkNotNull(client);
         this.oldState = checkNotNull(oldState);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
     private final Throwable throwable;
 
-    public ParserErrorEvent(final Parser parser, final Date date, final Throwable throwable) {
+    public ParserErrorEvent(final Parser parser, final LocalDateTime date,
+            final Throwable throwable) {
         super(parser, date);
         this.throwable = checkNotNull(throwable);
     }

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 public abstract class ParserEvent {
 
     private final Parser parser;
-    private final Date date;
+    private final LocalDateTime date;
 
-    public ParserEvent(final Parser parser, final Date date) {
+    public ParserEvent(final Parser parser, final LocalDateTime date) {
         this.parser = checkNotNull(parser);
         this.date = checkNotNull(date);
     }
         return parser;
     }
 
-    public Date getDate() {
+    public LocalDateTime getDate() {
         return date;
     }
 

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 /**
  * Interface Used when a raw 464 is recieved.
  */
 public class PasswordRequiredEvent extends ParserEvent {
 
-    public PasswordRequiredEvent(final Parser parser, final Date date) {
+    public PasswordRequiredEvent(final Parser parser, final LocalDateTime date) {
         super(parser, date);
     }
 }

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 /**
  * Called when a Ping Failed.
  */
 public class PingFailureEvent extends ParserEvent {
 
-    public PingFailureEvent(final Parser parser, final Date date) {
+    public PingFailureEvent(final Parser parser, final LocalDateTime date) {
         super(parser, date);
     }
 }

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 /**
  * Called when a Ping was Sent.
  */
 public class PingSentEvent extends ParserEvent {
 
-    public PingSentEvent(final Parser parser, final Date date) {
+    public PingSentEvent(final Parser parser, final LocalDateTime date) {
         super(parser, date);
     }
 }

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 /**
  * Called when a Ping was a Success.
  */
 public class PingSuccessEvent extends ParserEvent {
 
-    public PingSuccessEvent(final Parser parser, final Date date) {
+    public PingSuccessEvent(final Parser parser, final LocalDateTime date) {
         super(parser, date);
     }
 }

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String message;
     private final String host;
 
-    public PrivateActionEvent(final Parser parser, final Date date, final String message,
+    public PrivateActionEvent(final Parser parser, final LocalDateTime date, final String message,
             final String host) {
         super(parser, date);
         this.message = checkNotNull(message);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String message;
     private final String host;
 
-    public PrivateCTCPEvent(final Parser parser, final Date date, final String type,
+    public PrivateCTCPEvent(final Parser parser, final LocalDateTime date, final String type,
             final String message, final String host) {
         super(parser, date);
         this.type = checkNotNull(type);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String message;
     private final String host;
 
-    public PrivateCTCPReplyEvent(final Parser parser, final Date date, final String type,
+    public PrivateCTCPReplyEvent(final Parser parser, final LocalDateTime date, final String type,
             final String message, final String host) {
         super(parser, date);
         this.type = checkNotNull(type);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String message;
     private final String host;
 
-    public PrivateMessageEvent(final Parser parser, final Date date, final String message,
+    public PrivateMessageEvent(final Parser parser, final LocalDateTime date, final String message,
             final String host) {
         super(parser, date);
         this.message = checkNotNull(message);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String message;
     private final String host;
 
-    public PrivateNoticeEvent(final Parser parser, final Date date, final String message,
+    public PrivateNoticeEvent(final Parser parser, final LocalDateTime date, final String message,
             final String host) {
         super(parser, date);
         this.message = checkNotNull(message);

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

 import com.dmdirc.parser.interfaces.ClientInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final ClientInfo client;
     private final String reason;
 
-    public QuitEvent(final Parser parser, final Date date, final ClientInfo client,
+    public QuitEvent(final Parser parser, final LocalDateTime date, final ClientInfo client,
             final String reason) {
         super(parser, date);
         this.client = checkNotNull(client);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
     private final String message;
 
-    public ServerErrorEvent(final Parser parser, final Date date, final String message) {
+    public ServerErrorEvent(final Parser parser, final LocalDateTime date, final String message) {
         super(parser, date);
         this.message = checkNotNull(message);
     }

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String message;
     private final String host;
 
-    public ServerNoticeEvent(final Parser parser, final Date date, final String message,
+    public ServerNoticeEvent(final Parser parser, final LocalDateTime date, final String message,
             final String host) {
         super(parser, date);
         this.message = checkNotNull(message);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 /**
  * Called after 001.
  */
 public class ServerReadyEvent extends ParserEvent {
 
-    public ServerReadyEvent(final Parser parser, final Date date) {
+    public ServerReadyEvent(final Parser parser, final LocalDateTime date) {
         super(parser, date);
     }
 }

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 /**
  * Called when the socket is closed.
  */
 public class SocketCloseEvent extends ParserEvent {
 
-    public SocketCloseEvent(final Parser parser, final Date date) {
+    public SocketCloseEvent(final Parser parser, final LocalDateTime date) {
         super(parser, date);
     }
 }

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String target;
     private final String host;
 
-    public UnknownActionEvent(final Parser parser, final Date date, final String message,
+    public UnknownActionEvent(final Parser parser, final LocalDateTime date, final String message,
             final String target, final String host) {
         super(parser, date);
         this.message = checkNotNull(message);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String target;
     private final String host;
 
-    public UnknownCTCPEvent(final Parser parser, final Date date, final String type,
+    public UnknownCTCPEvent(final Parser parser, final LocalDateTime date, final String type,
             final String message, final String target, final String host) {
         super(parser, date);
         this.type = checkNotNull(type);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String target;
     private final String host;
 
-    public UnknownCTCPReplyEvent(final Parser parser, final Date date, final String type,
+    public UnknownCTCPReplyEvent(final Parser parser, final LocalDateTime date, final String type,
             final String message, final String target, final String host) {
         super(parser, date);
         this.type = checkNotNull(type);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String target;
     private final String host;
 
-    public UnknownMessageEvent(final Parser parser, final Date date,
+    public UnknownMessageEvent(final Parser parser, final LocalDateTime date,
             final String message, final String target, final String host) {
         super(parser, date);
         this.message = checkNotNull(message);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String target;
     private final String host;
 
-    public UnknownNoticeEvent(final Parser parser, final Date date,
+    public UnknownNoticeEvent(final Parser parser, final LocalDateTime date,
             final String message, final String target, final String host) {
         super(parser, date);
         this.message = checkNotNull(message);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String target;
     private final String host;
 
-    public UnknownServerNoticeEvent(final Parser parser, final Date date, final String message,
-            final String target, final String host) {
+    public UnknownServerNoticeEvent(final Parser parser, final LocalDateTime date,
+            final String message, final String target, final String host) {
         super(parser, date);
         this.message = checkNotNull(message);
         this.target = checkNotNull(target);

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

 import com.dmdirc.parser.interfaces.ClientInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
+import java.time.LocalDateTime;
 import java.util.Collections;
-import java.util.Date;
 import java.util.EnumMap;
 import java.util.Map;
 import java.util.Optional;
     private final ClientInfo client;
     private final Map<UserInfoType, String> info;
 
-    public UserInfoEvent(final Parser parser, final Date date, final ClientInfo client,
+    public UserInfoEvent(final Parser parser, final LocalDateTime date, final ClientInfo client,
             final Map<UserInfoType, String> info) {
         super(parser, date);
         this.client = client;

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

 import com.dmdirc.parser.interfaces.ClientInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String host;
     private final String modes;
 
-    public UserModeChangeEvent(final Parser parser, final Date date, final ClientInfo client,
-            final String host, final String modes) {
+    public UserModeChangeEvent(final Parser parser, final LocalDateTime date,
+            final ClientInfo client, final String host, final String modes) {
         super(parser, date);
         this.client = checkNotNull(client);
         this.host = checkNotNull(host);

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

 import com.dmdirc.parser.interfaces.ClientInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final ClientInfo client;
     private final String modes;
 
-    public UserModeDiscoveryEvent(final Parser parser, final Date date, final ClientInfo client,
-            final String modes) {
+    public UserModeDiscoveryEvent(final Parser parser, final LocalDateTime date,
+            final ClientInfo client, final String modes) {
         super(parser, date);
         this.client = checkNotNull(client);
         this.modes = checkNotNull(modes);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String message;
     private final String host;
 
-    public WallDesyncEvent(final Parser parser, final Date date, final String message,
+    public WallDesyncEvent(final Parser parser, final LocalDateTime date, final String message,
             final String host) {
         super(parser, date);
         this.message = checkNotNull(message);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String message;
     private final String host;
 
-    public WallopEvent(final Parser parser, final Date date, final String message,
+    public WallopEvent(final Parser parser, final LocalDateTime date, final String message,
             final String host) {
         super(parser, date);
         this.message = checkNotNull(message);

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

 
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
     private final String message;
     private final String host;
 
-    public WalluserEvent(final Parser parser, final Date date, final String message,
+    public WalluserEvent(final Parser parser, final LocalDateTime date, final String message,
             final String host) {
         super(parser, date);
         this.message = checkNotNull(message);

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

 import java.security.KeyManagementException;
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.Date;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
      * @param message The error message
      */
     protected void callServerError(final String message) {
-        getCallbackManager().publish(new ServerErrorEvent(this, new Date(), message));
+        getCallbackManager().publish(new ServerErrorEvent(this, LocalDateTime.now(), message));
     }
 
     /**
      * @param data Incoming Line.
      */
     protected void callDataIn(final String data) {
-        getCallbackManager().publish(new DataInEvent(this, new Date(), data));
+        getCallbackManager().publish(new DataInEvent(this, LocalDateTime.now(), data));
     }
 
     /**
      * @param fromParser True if parser sent the data, false if sent using .sendLine
      */
     protected void callDataOut(final String data, final boolean fromParser) {
-        getCallbackManager().publish(new DataOutEvent(this, new Date(), data));
+        getCallbackManager().publish(new DataOutEvent(this, LocalDateTime.now(), data));
     }
 
     /**
      * @param data Debugging Information
      */
     protected void callDebugInfo(final int level, final String data) {
-        getCallbackManager().publish(new DebugInfoEvent(this, new Date(), level, data));
+        getCallbackManager().publish(new DebugInfoEvent(this, LocalDateTime.now(), level, data));
     }
 
     /**
      * @param errorInfo ParserError object representing the error.
      */
     public void callErrorInfo(final ParserError errorInfo) {
-        getCallbackManager().publish(new ErrorInfoEvent(this, new Date(), errorInfo));
+        getCallbackManager().publish(new ErrorInfoEvent(this, LocalDateTime.now(), errorInfo));
     }
 
     /**
      * @param errorInfo ParserError object representing the error.
      */
     protected void callConnectError(final ParserError errorInfo) {
-        getCallbackManager().publish(new ConnectErrorEvent(this, new Date(), errorInfo));
+        getCallbackManager().publish(new ConnectErrorEvent(this, LocalDateTime.now(), errorInfo));
     }
 
     /**
         // Don't allow state resetting whilst there may be handlers requiring
         // state.
         synchronized (resetStateSync) {
-            getCallbackManager().publish(new SocketCloseEvent(this, new Date()));
+            getCallbackManager().publish(new SocketCloseEvent(this, LocalDateTime.now()));
         }
     }
 
      * Callback to all objects implementing the PingFailed Callback.
      */
     protected void callPingFailed() {
-        getCallbackManager().publish(new PingFailureEvent(this, new Date()));
+        getCallbackManager().publish(new PingFailureEvent(this, LocalDateTime.now()));
     }
 
     /**
      * Callback to all objects implementing the PingSent Callback.
      */
     protected void callPingSent() {
-        getCallbackManager().publish(new PingSentEvent(this, new Date()));
+        getCallbackManager().publish(new PingSentEvent(this, LocalDateTime.now()));
     }
 
     /**
      * Callback to all objects implementing the PingSuccess Callback.
      */
     protected void callPingSuccess() {
-        getCallbackManager().publish(new PingSuccessEvent(this, new Date()));
+        getCallbackManager().publish(new PingSuccessEvent(this, LocalDateTime.now()));
     }
 
     /**
         }
 
         whoisHandler.start();
-        getCallbackManager().publish(new ServerReadyEvent(this, new Date()));
+        getCallbackManager().publish(new ServerReadyEvent(this, LocalDateTime.now()));
     }
 
     //---------------------------------------------------------------------------
     protected void processLine(final ReadLine line) {
         callDataIn(line.getLine());
         final String[] token = line.getTokens();
-        Date lineTS = new Date();
+        LocalDateTime lineTS = LocalDateTime.now();
 
         if (line.getTags().containsKey("tsirc date")) {
             try {
-                final long ts = Long.parseLong(line.getTags().get("tsirc date"));
-                lineTS = new Date(ts - tsdiff);
+                final long ts = Long.parseLong(line.getTags().get("tsirc date")) - tsdiff;
+                lineTS = LocalDateTime.ofEpochSecond(ts / 1000L, (int) (ts % 1000L), ZoneOffset.UTC);
             } catch (final NumberFormatException nfe) { /* Do nothing. */ }
         } else if (line.getTags().containsKey("time")) {
-            final SimpleDateFormat servertime = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
             try {
-                lineTS = servertime.parse(line.getTags().get("time"));
-            } catch (final ParseException pe) { /* Do nothing. */ }
+                lineTS = LocalDateTime.parse(line.getTags().get("time"),
+                        DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"));
+            } catch (final DateTimeParseException pe) { /* Do nothing. */ }
         }
 
         setPingNeeded(false);

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

 import com.dmdirc.parser.events.NumericEvent;
 import com.dmdirc.parser.irc.processors.IRCProcessor;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
      * @throws ProcessorNotFoundException exception if no processors exists to handle the line
      */
     public void process(final String sParam, final String... token) throws ProcessorNotFoundException {
-        process(new Date(), sParam, token);
+        process(LocalDateTime.now(), sParam, token);
     }
 
     /**
      * @param token IRCTokenised line to process
      * @throws ProcessorNotFoundException exception if no processors exists to handle the line
      */
-    public void process(final Date date, final String sParam, final String... token) throws ProcessorNotFoundException {
+    public void process(final LocalDateTime date, final String sParam, final String... token)
+            throws ProcessorNotFoundException {
         IRCProcessor messageProcessor = null;
         try {
             messageProcessor = getProcessor(sParam);
      * @param token IRC Tokenised line
      */
     protected void callNumeric(final int numeric, final String... token) {
-        parser.getCallbackManager().publish(new NumericEvent(parser, new Date(), numeric, token));
+        parser.getCallbackManager().publish(new NumericEvent(parser, LocalDateTime.now(), numeric,
+                token));
     }
 }

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

 import com.dmdirc.parser.events.NickInUseEvent;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import net.engio.mbassy.listener.Handler;
 import net.engio.mbassy.listener.Listener;
 
     private void callDebugInfo(final Parser parser, final int level, final String data) {
         parser.getCallbackManager().publish(
-                new DebugInfoEvent(parser, new Date(), level, data));
+                new DebugInfoEvent(parser, LocalDateTime.now(), level, data));
     }
 
     /**

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

 
 import com.dmdirc.parser.irc.processors.IRCProcessor;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 /**
  * TimestampedIRCProcessor.
 
     @Override
     public final void process(final String sParam, final String... token) {
-        process(new Date(), sParam, token);
+        process(LocalDateTime.now(), sParam, token);
     }
 
     /**
      * @param sParam Type of line to process ("005", "PRIVMSG" etc)
      * @param token IRCTokenised line to process
      */
-    public abstract void process(final Date date, final String sParam, final String... token);
+    public abstract void process(final LocalDateTime date, final String sParam,
+            final String... token);
 
 
 }

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

 import com.dmdirc.parser.events.UserInfoEvent.UserInfoType;
 import com.dmdirc.parser.interfaces.Parser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 import java.util.EnumMap;
 import java.util.Map;
 
     }
 
     private void sendEvent() {
-        manager.publish(new UserInfoEvent(parser, new Date(), parser.getClient(client), info));
+        manager.publish(new UserInfoEvent(parser, LocalDateTime.now(),
+                parser.getClient(client), info));
     }
 
 }

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

 import com.dmdirc.parser.irc.IRCParser;
 import com.dmdirc.parser.irc.ProcessorNotFoundException;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
         final String ircdType = parser.getServerSoftwareType();
 
         getCallbackManager().publish(
-                new NetworkDetectedEvent(parser, new Date(), networkName, ircdVersion, ircdType));
+                new NetworkDetectedEvent(parser, LocalDateTime.now(), networkName, ircdVersion,
+                        ircdType));
     }
 
     /**

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

 import com.dmdirc.parser.events.PasswordRequiredEvent;
 import com.dmdirc.parser.irc.IRCParser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import javax.inject.Inject;
 
      * Callback to all objects implementing the PasswordRequired Callback.
      */
     protected void callPasswordRequired() {
-        getCallbackManager().publish(new PasswordRequiredEvent(parser, new Date()));
+        getCallbackManager().publish(new PasswordRequiredEvent(parser, LocalDateTime.now()));
     }
 }

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

 import com.dmdirc.parser.irc.IRCClientInfo;
 import com.dmdirc.parser.irc.IRCParser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import javax.inject.Inject;
 
     protected void callAwayState(final AwayState oldState, final AwayState currentState,
             final String reason) {
         getCallbackManager().publish(
-                new AwayStateEvent(parser, new Date(), oldState, currentState, reason));
+                new AwayStateEvent(parser, LocalDateTime.now(), oldState, currentState, reason));
     }
 
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessCap.java

 import com.dmdirc.parser.irc.IRCParser;
 import com.dmdirc.parser.irc.TimestampedIRCProcessor;
 
+import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Date;
 
 import javax.inject.Inject;
 
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final Date date, final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
         // We will only automatically handle the first ever pre-001 CAP LS
         // response.
         // After that, the user may be sending stuff themselves so we do

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

 import com.dmdirc.parser.events.InviteEvent;
 import com.dmdirc.parser.irc.IRCParser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import javax.inject.Inject;
 
      * @param channel The name of the channel we were invited to
      */
     protected void callInvite(final String userHost, final String channel) {
-        getCallbackManager().publish(new InviteEvent(parser, new Date(), userHost, channel));
+        getCallbackManager().publish(new InviteEvent(
+                parser, LocalDateTime.now(), userHost, channel));
     }
 
 }

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

 import com.dmdirc.parser.irc.PrefixModeManager;
 import com.dmdirc.parser.irc.ProcessorNotFoundException;
 
+import java.time.LocalDateTime;
 import java.util.Arrays;
-import java.util.Date;
 
 import javax.inject.Inject;
 import javax.inject.Named;
     protected void callChannelJoin(final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient) {
         getCallbackManager().publish(
-                new ChannelJoinEvent(parser, new Date(), cChannel, cChannelClient));
+                new ChannelJoinEvent(parser, LocalDateTime.now(), cChannel, cChannelClient));
     }
 
     /**
      * @param cChannel Channel Object
      */
     protected void callChannelSelfJoin(final ChannelInfo cChannel) {
-        getCallbackManager().publish(new ChannelSelfJoinEvent(parser, new Date(), cChannel));
+        getCallbackManager().publish(new ChannelSelfJoinEvent(
+                parser, LocalDateTime.now(), cChannel));
     }
 
 }

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

 import com.dmdirc.parser.irc.IRCClientInfo;
 import com.dmdirc.parser.irc.IRCParser;
 
+import java.time.LocalDateTime;
 import java.util.Arrays;
-import java.util.Date;
 
 import javax.inject.Inject;
 
             final ChannelClientInfo cKickedClient, final ChannelClientInfo cKickedByClient,
             final String sReason, final String sKickedByHost) {
         getCallbackManager().publish(
-                new ChannelKickEvent(parser, new Date(), cChannel, cKickedClient, cKickedByClient,
-                        sReason, sKickedByHost));
+                new ChannelKickEvent(parser, LocalDateTime.now(), cChannel, cKickedClient,
+                        cKickedByClient, sReason, sKickedByHost));
     }
 
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessList.java

 import com.dmdirc.parser.events.GroupListStartEvent;
 import com.dmdirc.parser.irc.IRCParser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import javax.inject.Inject;
 
         // :port80b.se.quakenet.org 323 MD87 :End of /LIST
         switch (sParam) {
             case "321":
-                getCallbackManager().publish(new GroupListStartEvent(parser, new Date()));
+                getCallbackManager().publish(new GroupListStartEvent(parser, LocalDateTime.now()));
                 break;
             case "322":
-                getCallbackManager().publish(new GroupListEntryEvent(parser, new Date(), token[3],
-                        Integer.parseInt(token[4]), token[5]));
+                getCallbackManager().publish(new GroupListEntryEvent(parser, LocalDateTime.now(),
+                        token[3], Integer.parseInt(token[4]), token[5]));
                 break;
             case "323":
-                getCallbackManager().publish(new GroupListEndEvent(parser, new Date()));
+                getCallbackManager().publish(new GroupListEndEvent(parser, LocalDateTime.now()));
                 break;
         }
     }

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

 import com.dmdirc.parser.irc.ServerType;
 import com.dmdirc.parser.irc.ServerTypeGroup;
 
+import java.time.LocalDateTime;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.Date;
 import java.util.Queue;
 
 import javax.inject.Inject;
      * @param mode the mode that we got list modes for.
      */
     protected void callChannelGotListModes(final ChannelInfo cChannel, final char mode) {
-        getCallbackManager().publish(new ChannelListModeEvent(parser, new Date(), cChannel, mode));
+        getCallbackManager().publish(new ChannelListModeEvent(parser, LocalDateTime.now(), cChannel,
+                mode));
     }
 }

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

 import com.dmdirc.parser.events.MOTDStartEvent;
 import com.dmdirc.parser.irc.IRCParser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import javax.inject.Inject;
 
      * @param data The contents of the line (incase of language changes or so)
      */
     protected void callMOTDEnd(final boolean noMOTD, final String data) {
-        getCallbackManager().publish(new MOTDEndEvent(parser, new Date(), noMOTD, data));
+        getCallbackManager().publish(new MOTDEndEvent(parser, LocalDateTime.now(), noMOTD, data));
     }
 
     /**
      * @param data Incomming Line.
      */
     protected void callMOTDLine(final String data) {
-        getCallbackManager().publish(new MOTDLineEvent(parser, new Date(), data));
+        getCallbackManager().publish(new MOTDLineEvent(parser, LocalDateTime.now(), data));
     }
 
     /**
      * @param data Incomming Line.
      */
     protected void callMOTDStart(final String data) {
-        getCallbackManager().publish(new MOTDStartEvent(parser, new Date(), data));
+        getCallbackManager().publish(new MOTDStartEvent(parser, LocalDateTime.now(), data));
     }
 
 }

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

 import com.dmdirc.parser.irc.ProcessorNotFoundException;
 import com.dmdirc.parser.irc.TimestampedIRCProcessor;
 
+import java.time.LocalDateTime;
 import java.util.Date;
 import java.util.regex.PatternSyntaxException;
 
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final Date date, final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
         // Ignore people!
         String sMessage;
         if (token[0].charAt(0) == ':') {
      * @param sMessage action contents
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callChannelAction(final Date date, final ChannelInfo cChannel,
+    protected void callChannelAction(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
         getCallbackManager().publish(
                 new ChannelActionEvent(parser, date, cChannel, cChannelClient, sMessage, sHost));
      * @param sMessage Additional contents
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callChannelCTCP(final Date date, final ChannelInfo cChannel,
+    protected void callChannelCTCP(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sType, final String sMessage,
             final String sHost) {
         getCallbackManager().publish(
      * @param sMessage Reply Contents
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callChannelCTCPReply(final Date date, final ChannelInfo cChannel,
+    protected void callChannelCTCPReply(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sType, final String sMessage,
             final String sHost) {
         getCallbackManager().publish(
      * @param sMessage Message contents
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callChannelMessage(final Date date, final ChannelInfo cChannel,
+    protected void callChannelMessage(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
         getCallbackManager().publish(
                 new ChannelMessageEvent(parser, date, cChannel, cChannelClient, sMessage, sHost));
      * @param sMessage notice contents
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callChannelNotice(final Date date, final ChannelInfo cChannel,
+    protected void callChannelNotice(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
         getCallbackManager().publish(
                 new ChannelNoticeEvent(parser, date, cChannel, cChannelClient, sMessage, sHost));
      * @param sMessage notice contents
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callChannelModeNotice(final Date date, final char prefix,
+    protected void callChannelModeNotice(final LocalDateTime date, final char prefix,
             final ChannelInfo cChannel, final ChannelClientInfo cChannelClient,
             final String sMessage, final String sHost) {
         getCallbackManager().publish(
      * @param sMessage message contents
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callChannelModeMessage(final Date date, final char prefix,
+    protected void callChannelModeMessage(final LocalDateTime date, final char prefix,
             final ChannelInfo cChannel, final ChannelClientInfo cChannelClient,
             final String sMessage, final String sHost) {
         getCallbackManager().publish(
      * @param sMessage action contents
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callPrivateAction(final Date date, final String sMessage, final String sHost) {
+    protected void callPrivateAction(final LocalDateTime date, final String sMessage,
+            final String sHost) {
         getCallbackManager().publish(new PrivateActionEvent(parser, date, sMessage, sHost));
     }
 
      * @param sMessage Additional contents
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callPrivateCTCP(final Date date, final String sType, final String sMessage,
-            final String sHost) {
+    protected void callPrivateCTCP(final LocalDateTime date, final String sType,
+            final String sMessage, final String sHost) {
         getCallbackManager().publish(new PrivateCTCPEvent(parser, date, sType, sMessage, sHost));
     }
 
      * @param sMessage Reply Contents
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callPrivateCTCPReply(final Date date, final String sType, final String sMessage,
-            final String sHost) {
+    protected void callPrivateCTCPReply(final LocalDateTime date, final String sType,
+            final String sMessage, final String sHost) {
         getCallbackManager().publish(
                 new PrivateCTCPReplyEvent(parser, date, sType, sMessage, sHost));
     }
      * @param sMessage Message contents
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callPrivateMessage(final Date date, final String sMessage, final String sHost) {
+    protected void callPrivateMessage(final LocalDateTime date, final String sMessage,
+            final String sHost) {
         getCallbackManager().publish(new PrivateMessageEvent(parser, date, sMessage, sHost));
     }
 
      * @param sMessage Notice contents
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callPrivateNotice(final Date date, final String sMessage, final String sHost) {
+    protected void callPrivateNotice(final LocalDateTime date, final String sMessage,
+            final String sHost) {
         getCallbackManager().publish(new PrivateNoticeEvent(parser, date, sMessage, sHost));
     }
 
      * @param sMessage Notice contents
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callServerNotice(final Date date, final String sMessage, final String sHost) {
+    protected void callServerNotice(final LocalDateTime date, final String sMessage,
+            final String sHost) {
         getCallbackManager().publish(new ServerNoticeEvent(parser, date, sMessage, sHost));
     }
 
      * @param sTarget Actual target of action
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callUnknownAction(final Date date, final String sMessage, final String sTarget,
-            final String sHost) {
+    protected void callUnknownAction(final LocalDateTime date, final String sMessage,
+            final String sTarget, final String sHost) {
         getCallbackManager().publish(new UnknownActionEvent(parser, date, sMessage, sTarget, sHost));
     }
 
      * @param sTarget Actual Target of CTCP
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callUnknownCTCP(final Date date, final String sType, final String sMessage,
-            final String sTarget, final String sHost) {
+    protected void callUnknownCTCP(final LocalDateTime date, final String sType,
+            final String sMessage, final String sTarget, final String sHost) {
         getCallbackManager().publish(
                 new UnknownCTCPEvent(parser, date, sType, sMessage, sTarget, sHost));
     }
      * @param sTarget Actual Target of CTCPReply
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callUnknownCTCPReply(final Date date, final String sType, final String sMessage,
-            final String sTarget, final String sHost) {
+    protected void callUnknownCTCPReply(final LocalDateTime date, final String sType,
+            final String sMessage, final String sTarget, final String sHost) {
         getCallbackManager().publish(
                 new UnknownCTCPReplyEvent(parser, date, sType, sMessage, sTarget, sHost));
     }
      * @param sTarget Actual target of message
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callUnknownMessage(final Date date, final String sMessage, final String sTarget,
-            final String sHost) {
+    protected void callUnknownMessage(final LocalDateTime date, final String sMessage,
+            final String sTarget, final String sHost) {
         getCallbackManager().publish(
                 new UnknownMessageEvent(parser, date, sMessage, sTarget, sHost));
     }
      * @param sTarget Actual target of notice
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callUnknownNotice(final Date date, final String sMessage, final String sTarget,
-            final String sHost) {
-        getCallbackManager().publish(new UnknownNoticeEvent(parser, date, sMessage, sTarget, sHost));
+    protected void callUnknownNotice(final LocalDateTime date, final String sMessage,
+            final String sTarget, final String sHost) {
+        getCallbackManager().publish(new UnknownNoticeEvent(parser, date, sMessage, sTarget,
+                sHost));
     }
 
     /**
      * @param sTarget Actual target of notice
      * @param sHost Hostname of sender (or servername)
      */
-    protected void callUnknownServerNotice(final Date date, final String sMessage,
+    protected void callUnknownServerNotice(final LocalDateTime date, final String sMessage,
             final String sTarget, final String sHost) {
         getCallbackManager().publish(
                 new UnknownServerNoticeEvent(parser, date, sMessage, sTarget, sHost));

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

 import com.dmdirc.parser.irc.ModeManager;
 import com.dmdirc.parser.irc.PrefixModeManager;
 
+import java.time.LocalDateTime;
 import java.util.Calendar;
-import java.util.Date;
 
 import javax.inject.Inject;
 import javax.inject.Named;
                         callDebugInfo(IRCParser.DEBUG_INFO, "List Mode: %c [%s] {Positive: %b}", cMode, sModeParam, bPositive);
                         if (!"324".equals(sParam)) {
                             getCallbackManager().publish(
-                                    new ChannelSingleModeChangeEvent(parser, new Date(), iChannel,
+                                    new ChannelSingleModeChangeEvent(
+                                            parser, LocalDateTime.now(), iChannel,
                                             setterCCI, token[0], cPositive + cMode + " " +
                                             sModeParam));
                         }
                             iChannel.setModeParam(cMode, sModeParam);
                             if (!"324".equals(sParam)) {
                                 getCallbackManager().publish(
-                                        new ChannelSingleModeChangeEvent(parser, new Date(),
+                                        new ChannelSingleModeChangeEvent(
+                                                parser, LocalDateTime.now(),
                                                 iChannel, setterCCI, token[0],
                                                 cPositive + cMode + " " +
                                                         sModeParam));
                             iChannel.setModeParam(cMode, "");
                             if (!"324".equals(sParam)) {
                                 getCallbackManager().publish(
-                                        new ChannelSingleModeChangeEvent(parser, new Date(),
+                                        new ChannelSingleModeChangeEvent(
+                                                parser, LocalDateTime.now(),
                                                 iChannel, setterCCI, token[0],
                                                 trim(cPositive + cMode + " " + sModeParam)));
                             }
         } else {
             callChannelModeChanged(iChannel, setterCCI, token[0], sFullModeStr.toString().trim());
             getCallbackManager().publish(
-                    new ChannelNonUserModeChangeEvent(parser, new Date(), iChannel, setterCCI,
-                            token[0], trim(sNonUserModeStr.toString() + sNonUserModeStrParams)));
+                    new ChannelNonUserModeChangeEvent(parser, LocalDateTime.now(), iChannel,
+                            setterCCI, token[0],
+                            trim(sNonUserModeStr.toString() + sNonUserModeStrParams)));
         }
     }
 
     protected void callChannelModeChanged(final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sHost, final String sModes) {
         getCallbackManager().publish(
-                new ChannelModeChangeEvent(parser, new Date(), cChannel, cChannelClient, sHost,
-                        sModes));
+                new ChannelModeChangeEvent(parser, LocalDateTime.now(), cChannel, cChannelClient,
+                        sHost, sModes));
     }
 
     /**
             final ChannelClientInfo cChangedClient, final ChannelClientInfo cSetByClient,
             final String sHost, final String sMode) {
         getCallbackManager().publish(
-                new ChannelUserModeChangeEvent(parser, new Date(), cChannel, cChangedClient,
-                        cSetByClient, sHost, sMode));
+                new ChannelUserModeChangeEvent(parser, LocalDateTime.now(), cChannel,
+                        cChangedClient, cSetByClient, sHost, sMode));
     }
 
     /**
     protected void callUserModeChanged(final ClientInfo cClient, final String sSetby,
             final String sModes) {
         getCallbackManager().publish(
-                new UserModeChangeEvent(parser, new Date(), cClient, sSetby, sModes));
+                new UserModeChangeEvent(parser, LocalDateTime.now(), cClient, sSetby, sModes));
     }
 
     /**
      */
     protected void callUserModeDiscovered(final ClientInfo cClient, final String sModes) {
         getCallbackManager().publish(
-                new UserModeDiscoveryEvent(parser, new Date(), cClient, sModes));
+                new UserModeDiscoveryEvent(parser, LocalDateTime.now(), cClient, sModes));
     }
 
 }

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

 import com.dmdirc.parser.irc.ModeManager;
 import com.dmdirc.parser.irc.PrefixModeManager;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import javax.inject.Inject;
 import javax.inject.Named;
     protected void callChannelTopic(final ChannelInfo cChannel, final boolean bIsJoinTopic) {
         ((IRCChannelInfo) cChannel).setHadTopic();
         getCallbackManager().publish(
-                new ChannelTopicEvent(parser, new Date(), cChannel, bIsJoinTopic));
+                new ChannelTopicEvent(parser, LocalDateTime.now(), cChannel, bIsJoinTopic));
     }
 
     /**
      * @param cChannel Channel which the names reply is for
      */
     protected void callChannelGotNames(final ChannelInfo cChannel) {
-        getCallbackManager().publish(new ChannelNamesEvent(parser, new Date(), cChannel));
+        getCallbackManager().publish(new ChannelNamesEvent(parser, LocalDateTime.now(), cChannel));
     }
 
 }

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

 import com.dmdirc.parser.irc.IRCClientInfo;
 import com.dmdirc.parser.irc.IRCParser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import javax.inject.Inject;
 
     protected void callChannelNickChanged(final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sOldNick) {
         getCallbackManager().publish(
-                new ChannelNickChangeEvent(parser, new Date(), cChannel, cChannelClient, sOldNick));
+                new ChannelNickChangeEvent(parser, LocalDateTime.now(), cChannel, cChannelClient,
+                        sOldNick));
     }
 
     /**
      * @param sOldNick Nickname before change
      */
     protected void callNickChanged(final ClientInfo cClient, final String sOldNick) {
-        getCallbackManager().publish(new NickChangeEvent(parser, new Date(), cClient, sOldNick));
+        getCallbackManager().publish(new NickChangeEvent(parser, LocalDateTime.now(), cClient,
+                sOldNick));
     }
 
 }

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

 import com.dmdirc.parser.events.NickInUseEvent;
 import com.dmdirc.parser.irc.IRCParser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import javax.inject.Inject;
 
      * @param nickname Nickname that was wanted.
      */
     protected void callNickInUse(final String nickname) {
-        getCallbackManager().publish(new NickInUseEvent(parser, new Date(), nickname));
+        getCallbackManager().publish(new NickInUseEvent(parser, LocalDateTime.now(), nickname));
     }
 
 }

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

 import com.dmdirc.parser.events.AuthNoticeEvent;
 import com.dmdirc.parser.irc.IRCParser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import javax.inject.Inject;
 
      * @param data Incomming Line.
      */
     protected void callNoticeAuth(final String data) {
-        getCallbackManager().publish(new AuthNoticeEvent(parser, new Date(), data));
+        getCallbackManager().publish(new AuthNoticeEvent(parser, LocalDateTime.now(), data));
     }
 
 }

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

 import com.dmdirc.parser.irc.IRCClientInfo;
 import com.dmdirc.parser.irc.IRCParser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import javax.inject.Inject;
 
     protected void callChannelPart(final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sReason) {
         getCallbackManager().publish(
-                new ChannelPartEvent(parser, new Date(), cChannel, cChannelClient, sReason));
+                new ChannelPartEvent(parser, LocalDateTime.now(), cChannel, cChannelClient,
+                        sReason));
     }
 
 }

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

 import com.dmdirc.parser.irc.IRCClientInfo;
 import com.dmdirc.parser.irc.IRCParser;
 
+import java.time.LocalDateTime;
 import java.util.ArrayList;
-import java.util.Date;
 
 import javax.inject.Inject;
 
     protected void callChannelQuit(final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sReason) {
         getCallbackManager().publish(
-                new ChannelQuitEvent(parser, new Date(), cChannel, cChannelClient, sReason));
+                new ChannelQuitEvent(parser, LocalDateTime.now(), cChannel, cChannelClient,
+                        sReason));
     }
 
     /**
      * @param sReason Reason for quitting (may be "")
      */
     protected void callQuit(final ClientInfo cClient, final String sReason) {
-        getCallbackManager().publish(new QuitEvent(parser, new Date(), cClient, sReason));
+        getCallbackManager().publish(new QuitEvent(parser, LocalDateTime.now(), cClient, sReason));
     }
 
 }

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

 import com.dmdirc.parser.irc.IRCClientInfo;
 import com.dmdirc.parser.irc.IRCParser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import javax.inject.Inject;
 
     protected void callChannelTopic(final ChannelInfo cChannel, final boolean bIsJoinTopic) {
         ((IRCChannelInfo) cChannel).setHadTopic();
         getCallbackManager().publish(
-                new ChannelTopicEvent(parser, new Date(), cChannel, bIsJoinTopic));
+                new ChannelTopicEvent(parser, LocalDateTime.now(), cChannel, bIsJoinTopic));
     }
 
 }

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

 import com.dmdirc.parser.events.WalluserEvent;
 import com.dmdirc.parser.irc.IRCParser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import javax.inject.Inject;
 
      * @param host Host of the user who sent the wallop
      */
     protected void callWallop(final String message, final String host) {
-        getCallbackManager().publish(new WallopEvent(parser, new Date(), message, host));
+        getCallbackManager().publish(new WallopEvent(parser, LocalDateTime.now(), message, host));
     }
 
     /**
      * @param host Host of the user who sent the walluser
      */
     protected void callWalluser(final String message, final String host) {
-        getCallbackManager().publish(new WalluserEvent(parser, new Date(), message, host));
+        getCallbackManager().publish(new WalluserEvent(parser, LocalDateTime.now(), message, host));
     }
 
     /**
      * @param host Host of the user who sent the WallDesync
      */
     protected void callWallDesync(final String message, final String host) {
-        getCallbackManager().publish(new WallDesyncEvent(parser, new Date(), message, host));
+        getCallbackManager().publish(new WallDesyncEvent(
+                parser, LocalDateTime.now(), message, host));
     }
 
 }

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

 import com.dmdirc.parser.irc.IRCClientInfo;
 import com.dmdirc.parser.irc.IRCParser;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 import javax.inject.Inject;
 
     protected void callAwayState(final AwayState oldState, final AwayState currentState,
             final String reason) {
         getCallbackManager().publish(
-                new AwayStateEvent(parser, new Date(), oldState, currentState, reason));
+                new AwayStateEvent(parser, LocalDateTime.now(), oldState, currentState, reason));
     }
 
     /**
     protected void callAwayStateOther(final ClientInfo client, final AwayState oldState,
             final AwayState state) {
         getCallbackManager().publish(
-                new OtherAwayStateEvent(parser, new Date(), client, oldState, state));
+                new OtherAwayStateEvent(parser, LocalDateTime.now(), client, oldState, state));
     }
 
     /**
     protected void callChannelAwayStateOther(final ChannelInfo channel,
             final ChannelClientInfo channelClient, final AwayState oldState, final AwayState state) {
         getCallbackManager().publish(
-                new ChannelOtherAwayStateEvent(parser, new Date(), channel, channelClient, oldState,
-                        state));
+                new ChannelOtherAwayStateEvent(parser, LocalDateTime.now(), channel, channelClient,
+                        oldState, state));
     }
 
 }

xmpp/src/com/dmdirc/parser/xmpp/XmppFakeChannel.java

 import com.dmdirc.parser.interfaces.ClientInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
+import java.time.LocalDateTime;
 import java.util.Collection;
-import java.util.Date;
 
 /**
  * A 'fake' local channel used to display buddy lists.
 
         // TODO: Delete old contacts, don't needlessly create new objects
         getParser().getCallbackManager().publish(
-                new ChannelNamesEvent(getParser(), new Date(), this));
+                new ChannelNamesEvent(getParser(), LocalDateTime.now(), this));
     }
 
 }

xmpp/src/com/dmdirc/parser/xmpp/XmppParser.java

 import com.dmdirc.parser.interfaces.StringConverter;
 
 import java.net.URI;
+import java.time.LocalDateTime;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
         newArgs[2] = getLocalClient().getNickname();
         System.arraycopy(args, 0, newArgs, 3, args.length);
 
-        getCallbackManager().publish(new NumericEvent(this, new Date(), numeric, newArgs));
+        getCallbackManager().publish(new NumericEvent(this, LocalDateTime.now(), numeric, newArgs));
     }
 
     @Override
     @Override
     public void run() {
         if (getURI().getUserInfo() == null || !getURI().getUserInfo().contains(":")) {
-            getCallbackManager().publish(new ConnectErrorEvent(this, new Date(),
+            getCallbackManager().publish(new ConnectErrorEvent(this, LocalDateTime.now(),
                     new ParserError(ParserError.ERROR_USER,
                             "User name and password must be specified in URI", "")));
             return;
             try {
                 connection.login(userInfoParts[0], userInfoParts[1], "DMDirc.");
             } catch (XMPPException ex) {
-                getCallbackManager().publish(new ConnectErrorEvent(this, new Date(),
+                getCallbackManager().publish(new ConnectErrorEvent(this, LocalDateTime.now(),
                         new ParserError(ParserError.ERROR_USER, ex.getMessage(), "")));
                 return;
             }
 
             setServerName(connection.getServiceName());
 
-            getCallbackManager().publish(new ServerReadyEvent(this, new Date()));
+            getCallbackManager().publish(new ServerReadyEvent(this, LocalDateTime.now()));
 
             for (RosterEntry contact : connection.getRoster().getEntries()) {
                 getClient(contact.getUser()).setRosterEntry(contact);
 
                 contacts.values().stream().filter(XmppClientInfo::isAway).forEach(client ->
                         getCallbackManager().publish(
-                                new OtherAwayStateEvent(this, new Date(), client, AwayState.UNKNOWN,
-                                        AwayState.AWAY)));
+                                new OtherAwayStateEvent(this, LocalDateTime.now(), client,
+                                        AwayState.UNKNOWN, AwayState.AWAY)));
             }
         } catch (XMPPException ex) {
             LOG.debug("Go an XMPP exception", ex);
                 error.setException(ex);
             }
 
-            getCallbackManager().publish(new ConnectErrorEvent(this, new Date(), error));
+            getCallbackManager().publish(new ConnectErrorEvent(this, LocalDateTime.now(), error));
         }
     }
 
 
         if (useFakeChannel) {
             getCallbackManager().publish(new OtherAwayStateEvent(
-                    this, new Date(), client, isBack ? AwayState.AWAY : AwayState.HERE,
+                    this, LocalDateTime.now(), client, isBack ? AwayState.AWAY : AwayState.HERE,
                     isBack ? AwayState.HERE : AwayState.AWAY));
         }
     }
                 priority, Presence.Mode.away));
 
         getCallbackManager().publish(
-                new AwayStateEvent(this, new Date(), AwayState.HERE, AwayState.AWAY, reason));
+                new AwayStateEvent(this, LocalDateTime.now(), AwayState.HERE, AwayState.AWAY,
+                        reason));
     }
 
     /**
                 priority, Presence.Mode.available));
 
         getCallbackManager().publish(
-                new AwayStateEvent(this, new Date(), AwayState.AWAY, AwayState.HERE, null));
+                new AwayStateEvent(this, LocalDateTime.now(), AwayState.AWAY, AwayState.HERE,
+                        null));
     }
 
     @Override
 
         @Override
         public void connectionClosed() {
-            getCallbackManager().publish(new SocketCloseEvent(XmppParser.this, new Date()));
+            getCallbackManager().publish(new SocketCloseEvent(XmppParser.this,
+                    LocalDateTime.now()));
         }
 
         @Override
         public void connectionClosedOnError(final Exception excptn) {
             // TODO: Handle exception
-            getCallbackManager().publish(new SocketCloseEvent(XmppParser.this, new Date()));
+            getCallbackManager().publish(new SocketCloseEvent(XmppParser.this,
+                    LocalDateTime.now()));
         }
 
         @Override
         @Override
         public void processMessage(final Chat chat, final Message msg) {
             if (msg.getType() == Message.Type.error) {
-                getCallbackManager().publish(new NumericEvent(XmppParser.this, new Date(), 404,
+                getCallbackManager().publish(new NumericEvent(XmppParser.this, LocalDateTime.now(),
+                        404,
                         new String[]{":xmpp", "404", getLocalClient().getNickname(), msg.getFrom(),
                                 "Cannot send message: " + msg.getError().toString()}));
                 return;
 
             if (msg.getBody() != null) {
                 if (msg.getBody().startsWith("/me ")) {
-                    getCallbackManager().publish(new PrivateActionEvent(XmppParser.this, new Date(),
+                    getCallbackManager().publish(new PrivateActionEvent(XmppParser.this,
+                            LocalDateTime.now(),
                             msg.getBody().substring(4), msg.getFrom()));
                 } else {
                     getCallbackManager().publish(
-                            new PrivateMessageEvent(XmppParser.this, new Date(), msg.getBody(),
+                            new PrivateMessageEvent(XmppParser.this,
+                                    LocalDateTime.now(), msg.getBody(),
                                     msg.getFrom()));
                 }
             }
             }
 
             getCallbackManager().publish(
-                    new CompositionStateChangeEvent(XmppParser.this, new Date(), state,
+                    new CompositionStateChangeEvent(XmppParser.this, LocalDateTime.now(), state,
                             chat.getParticipant()));
         }
 
         public void processPacket(final Packet packet) {
             if (dataOut) {
                 getCallbackManager().publish(
-                        new DataOutEvent(XmppParser.this, new Date(), packet.toXML()));
+                        new DataOutEvent(XmppParser.this, LocalDateTime.now(), packet.toXML()));
             } else {
                 getCallbackManager().publish(
-                        new DataInEvent(XmppParser.this, new Date(), packet.toXML()));
+                        new DataInEvent(XmppParser.this, LocalDateTime.now(), packet.toXML()));
             }
         }