Adds a Timer Manager that allows cancelling of timers

Fixes issue CLIENT-101

Change-Id: I47c6b053fe451cfd6f734959195926bad7fc6376
Reviewed-on: http://gerrit.dmdirc.com/1610
Automatic-Compile: DMDirc Local Commits <dmdirc@googlemail.com>
Reviewed-by: Chris Smith <chris@dmdirc.com>

src/com/dmdirc/addons/time/TimePlugin.java

 /*
- * Copyright (c) 2006-2010 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ * Copyright (c) 2006-2010 Chris Smith, Shane Mc Cormack, Gregory Holmes,
+ * Simon Mott
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * @author chris
  */
 public final class TimePlugin  extends Plugin {
-    
+
     /** Have we registered our types already? */
     private static boolean registered;
-    
+
     /** The timer to use for scheduling. */
     private Timer timer;
-    
+
     /** The TimerCommand we've registered. */
     private TimerCommand command;
-    
+
+    /** The Manager to use for managing timers. */
+    private TimerManager manager;
+
     /** Creates a new instance of TimePlugin. */
     public TimePlugin() {
         super();
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onLoad() {
         }
 
         final int offset = 60 - Calendar.getInstance().get(Calendar.SECOND);
-        
+
         timer = new Timer("Time plugin timer");
-        
+
         timer.schedule(new TimerTask() {
             /** {@inheritDoc} */
             @Override
                 runTimer();
             }
         }, 1000 * offset, 1000 * 60);
-        
-        command = new TimerCommand();
+
+        manager = new TimerManager();
+        command = new TimerCommand(manager);
         CommandManager.registerCommand(command);
     }
-    
+
     /** Handles a timer event that occurs every minute. */
     public void runTimer() {
         final Calendar cal = Calendar.getInstance();
-        
+
         ActionManager.processEvent(TimeActionType.TIME_MINUTE, null, cal);
-        
+
         if (cal.get(Calendar.MINUTE) == 0) {
             ActionManager.processEvent(TimeActionType.TIME_HOUR, null, cal);
-            
+
             if (cal.get(Calendar.HOUR_OF_DAY) == 0) {
                 ActionManager.processEvent(TimeActionType.TIME_DAY, null, cal);
             }
         }
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onUnload() {
             timer.cancel();
             timer = null;
         }
-        
+        manager = null;
         CommandManager.unregisterCommand(command);
     }
+
+    /**
+     * Returns the manager that is assigned to this Plugin.
+     *
+     * @return The Instance of TimeManager that is associated with this plugin
+     */
+    public TimerManager getTimerManager() {
+        return manager;
+    }
 }

src/com/dmdirc/addons/time/TimedCommand.java

 /*
- * Copyright (c) 2006-2010 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ * Copyright (c) 2006-2010 Chris Smith, Shane Mc Cormack, Gregory Holmes,
+ * Simon Mott
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * Timed command represents a command that has been scheduled by the user.
  */
 public final class TimedCommand extends TimerTask {
-    
+
     /** The number of repetitions remaining. */
     private int repetitions;
-    
+
     /** The command to execute. */
     private final String command;
-    
+
     /** The container to use for executing commands. */
     private final FrameContainer<?> origin;
 
     /** The window the command came from. */
     private final Window window;
-    
+
     /** The timer we're using for scheduling this command. */
     private final Timer timer;
-    
+
+    /** The key for this timer in the Timer Manager */
+    private final int timerKey;
+
+    /** The manager for this timer. */
+    private final TimerManager manager;
+
     /**
      * Creates a new instance of TimedCommand.
+     *
      * @param repetitions The number of times this command will be executed
      * @param delay The number of seconds between each execution
      * @param command The command to be executed
      * @param origin The frame container to use for the execution
      * @param window The window the command came from
      */
-    public TimedCommand(final int repetitions, final int delay,
-            final String command, final FrameContainer<?> origin,
-            final Window window) {
+    public TimedCommand(final TimerManager manager, final int timerKey,
+            final int repetitions, final int delay, final String command,
+            final FrameContainer<?> origin, final Window window) {
         super();
-        
+
+        this.timerKey = timerKey;
         this.repetitions = repetitions;
         this.command = command;
         this.origin = origin;
         this.window = window;
-        
+        this.manager = manager;
+
         timer = new Timer("Timed Command Timer");
         timer.schedule(this, delay * 1000L, delay * 1000L);
     }
 
+    /**
+     * Returns the command this timer is due to execute.
+     *
+     * @return Command the timer will run
+     * @since 0.6.5
+     */
+    public String getCommand() {
+        return command;
+    }
+
+    /**
+     * Cancels this timer and removes it from the Timer Manager
+     *
+     * @since 0.6.5
+     */
+    public void cancelTimer() {
+        manager.removeTimer(timerKey);
+        timer.cancel();
+    }
+
     /** {@inheritDoc} */
     @Override
     public void run() {
         } else {
             parser = ((WritableFrameContainer<?>) origin).getCommandParser();
         }
-        
+
         parser.parseCommand(origin, window, command);
-                
+
         if (--repetitions <= 0) {
+            manager.removeTimer(timerKey);
             timer.cancel();
         }
     }
-}
+}

src/com/dmdirc/addons/time/TimerCommand.java

 /*
- * Copyright (c) 2006-2010 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ * Copyright (c) 2006-2010 Chris Smith, Shane Mc Cormack, Gregory Holmes,
+ * Simon Mott
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
 import com.dmdirc.commandparser.commands.IntelligentCommand;
 import com.dmdirc.commandparser.commands.context.CommandContext;
 import com.dmdirc.ui.input.AdditionalTabTargets;
-import com.dmdirc.ui.input.TabCompleter;
+
+import java.util.Map.Entry;
+import java.util.Set;
 
 /**
  * The timer command allows users to schedule commands to occur after a certain
  */
 public final class TimerCommand extends Command implements IntelligentCommand,
         CommandInfo {
-    
+
+    /** The TimerManager for this TimerCommand. */
+    private final TimerManager manager;
+
     /**
      * Creates a new instance of TimerCommand.
+     *
+     * @param manager The instance of TimerManager associated with this command
      */
-    public TimerCommand() {
+    public TimerCommand(final TimerManager manager) {
         super();
+
+        this.manager = manager;
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void execute(final FrameContainer<?> origin,
             final CommandArguments args, final CommandContext context) {
-        if (args.getArguments().length < 3) {
-            doUsage(origin, args.isSilent());
-        } else {
-            int repetitions = 0;
-            int interval = 0;
-            final String command = args.getArgumentsAsString(2);
-            
-            try {
-                repetitions = Integer.parseInt(args.getArguments()[0]);
-                interval = Integer.parseInt(args.getArguments()[1]);
-            } catch (NumberFormatException ex) {
-                doUsage(origin, args.isSilent());
-                return;
-            }
 
-            if (interval < 1) {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR, "Cannot use" +
-                        " intervals below 1");
-                return;
-            }
+        if (args.getArguments().length > 0) {
+            if ("--cancel".equals(args.getArguments()[0])) {
+                int timerKey = 0;
+
+                try {
+                    timerKey = Integer.parseInt(args.getArgumentsAsString(1));
+                } catch (NumberFormatException ex) {
+                    doUsage(origin, args.isSilent());
+                    return;
+                }
+
+                if (manager.hasTimerWithID(timerKey)) {
+                    manager.getTimerByID(timerKey).cancelTimer();
+                    sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Timer cancelled");
+                } else {
+                    sendLine(origin, args.isSilent(), FORMAT_ERROR, "There is currently" +
+                            " no timer with that ID");
+                    return;
+                }
+            } else if ("--list".equals(args.getArguments()[0])) {
+                final Set<Entry<Integer, TimedCommand>> timerList
+                        = manager.listTimers();
+
+                if (!timerList.isEmpty()) {
+                    for (Entry<Integer, TimedCommand> entry : timerList) {
+                        sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Timer"
+                                + " ID: " + entry.getKey() + " - " +
+                                entry.getValue().getCommand());
+                    }
+                } else {
+                    sendLine(origin, args.isSilent(), FORMAT_ERROR, "There are " +
+                                "currently no active timers");
+                }
+            } else {
+                if (args.getArguments().length < 3) {
+                    doUsage(origin, args.isSilent());
+                } else {
+                    int repetitions = 0;
+                    int interval = 0;
+
+                    final String command = args.getArgumentsAsString(2);
+
+                    try {
+                        repetitions = Integer.parseInt(args.getArguments()[0]);
+                        interval = Integer.parseInt(args.getArguments()[1]);
+                    } catch (NumberFormatException ex) {
+                        doUsage(origin, args.isSilent());
+                        return;
+                    }
 
-            new TimedCommand(repetitions, interval, command, origin, context.getSource());
-            sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Command scheduled.");
+                    if (interval < 1) {
+                        sendLine(origin, args.isSilent(), FORMAT_ERROR, "Cannot use" +
+                                " intervals below 1");
+                        return;
+                    }
+
+                    manager.addTimer(repetitions, interval, command,
+                            origin, context.getSource());
+
+                    sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Command scheduled.");
+                }
+            }
+        } else {
+            doUsage(origin, args.isSilent());
         }
     }
-    
+
     /**
      * Displays usage information for this command.
      * @param origin The window that the command was entered in
      * @param isSilent Whether this command is being silenced or not
      */
     private void doUsage(final FrameContainer<?> origin, final boolean isSilent) {
-        showUsage(origin, isSilent, "timer", "<repetitions> <interval> <command>");
+        showUsage(origin, isSilent, "timer", "[--list|--cancel <timer id> | " +
+                "<repetitions> <interval> <command>]");
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public String getName() {
         return "timer";
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public boolean showInHelp() {
     public CommandType getType() {
         return CommandType.TYPE_GLOBAL;
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public String getHelp() {
-        return "timer <repetitions> <interval> <command> " +
-                "- schedules a command to be executed after a certain time";
+        return "timer [--list|--cancel <timer id> | <repetitions> <interval> <command>] " +
+                "- lists all active timers / cancells an active timer of given ID" +
+                " / schedules a command to be executed after a certain time";
     }
 
     /** {@inheritDoc} */
     @Override
     public AdditionalTabTargets getSuggestions(final int arg,
             final IntelligentCommandContext context) {
-        AdditionalTabTargets res;
-        
-        if (arg <= 1) {
-            res = new AdditionalTabTargets().excludeAll();
-        } else {
-            res = TabCompleter.getIntelligentResults(arg, context, 2);
+        final AdditionalTabTargets targets = new AdditionalTabTargets();
+
+        targets.excludeAll();
+        if (arg == 0) {
+            targets.add("--list");
+            targets.add("--cancel");
+        } else if (arg == 1 && "--cancel".equals(context.getPreviousArgs().get(0))) {
+            for (Integer i : manager.getTimerIDs()) {
+                targets.add(i.toString());
+            }
         }
-        
-        return res;
-    } 
-    
+
+        return targets;
+    }
 }

src/com/dmdirc/addons/time/TimerManager.java

+/*
+ * Copyright (c) 2006-2010 Chris Smith, Shane Mc Cormack, Gregory Holmes,
+ * Simon Mott
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.time;
+
+import com.dmdirc.FrameContainer;
+import com.dmdirc.ui.interfaces.Window;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+/**
+ * Class to manage Timers.
+ *
+ * @author Simon Mott
+ * @since 0.6.5
+ */
+public class TimerManager {
+
+    /** Map of all the timers that are running. */
+    private final Map<Integer, TimedCommand> timerList;
+
+    /** Creates a new instance of TimeManager. */
+    public TimerManager() {
+        timerList = new HashMap<Integer, TimedCommand>();
+    }
+
+    /**
+     * Adds a timer to the internal list and starts the timer.
+     *
+     * @param repetitions Amount of times the timer repeats
+     * @param interval Interval between repetitions
+     * @param command Command to be run when the timer fires
+     * @param origin The frame container to use for the execution
+     * @param commandContext The window the command came from
+     */
+    public void addTimer(final int repetitions, final int interval, String command,
+            final FrameContainer<?> origin, final Window commandContext) {
+
+        synchronized (this) {
+            final int timerKey = findFreeKey();
+            timerList.put(timerKey, new TimedCommand(this, timerKey, repetitions,
+                interval, command, origin, commandContext));
+        }
+    }
+
+    /**
+     * Removes a timer from our internal list of active timers. This should only
+     * be called when a timer is cancelled.
+     *
+     * @param timerKey Key of the timer to remove
+     */
+    public void removeTimer(final int timerKey) {
+        timerList.remove(timerKey);
+    }
+
+    /**
+     * Gets a list of all current active timers.
+     *
+     * @return Returns a set of keys for all active timers
+     */
+    public Set<Entry<Integer, TimedCommand>> listTimers() {
+        return timerList.entrySet();
+    }
+
+    /**
+     * Returns a list of all known Timer IDs.
+     *
+     * @return returns an Integer Set of Timer IDs
+     */
+    public Set<Integer> getTimerIDs() {
+        return timerList.keySet();
+    }
+
+    /**
+     * Locates a key in our list that is currently not being used by a timer.
+     *
+     * @return Returns a key that can be used for creating a new timer
+     */
+    private int findFreeKey() {
+        int i = 0;
+        while (timerList.containsKey(i)) {
+            i++;
+        }
+        return i;
+    }
+
+    /**
+     * Matches a Timer ID to a Timer.
+     * This will return null if there is no Timer with the provided ID.
+     *
+     * @param id ID that we want the timer for
+     *
+     * @return Returns the Timer for the ID provided or null if none exist
+     */
+    public TimedCommand getTimerByID(final int id) {
+        return timerList.get(id);
+    }
+
+    /**
+     * Checkes if there is a timer with the provided ID.
+     *
+     * @param id ID that we want to check if there is a timer for
+     *
+     * @return Returns True of there is a timer with the ID. False if there isn't
+     */
+    public boolean hasTimerWithID(final int id) {
+        return timerList.containsKey(id);
+    }
+
+}