src/net/pterodactylus/jsite/core/CoreListenerSupport.java

   1 /*
   2  * jSite-next - CoreListenerSupport.java -
   3  * Copyright © 2008 David Roden
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 package net.pterodactylus.jsite.core;
  21
  22 import java.util.logging.Level;
  23 import java.util.logging.Logger;
  24
  25 import net.pterodactylus.util.event.ListenerSupport;
  26
  27 /**
  28  * TODO
  29  *
  30  * @author David Roden &lt;droden@gmail.com&gt;
  31  */
  32 public class CoreListenerSupport extends ListenerSupport<CoreListener> {
  33
  34         /** The logger. */
  35         private static final Logger logger = Logger.getLogger(CoreListenerSupport.class.getName());
  36
  37         /**
  38          * Notifies all listeners that the projects were loaded successfully.
  39          *
  40          * @param directory
  41          *            The directory the projects were loaded from
  42          */
  43         public void fireLoadingProjectsDone(String directory) {
  44                 logger.log(Level.FINEST, "firing loadingProjectsDone event with [directory=" + directory + "]");
  45                 for (CoreListener coreListener : getListeners()) {
  46                         coreListener.loadingProjectsDone(directory);
  47                 }
  48         }
  49
  50         /**
  51          * Notifies all core listeners that loading the projects from the given
  52          * directory has failed.
  53          *
  54          * @param directory
  55          *            The directory the projects were tried to load from
  56          * @param throwable
  57          *            The exception that occured when loading projects
  58          */
  59         public void fireLoadingProjectsFailed(String directory, Throwable throwable) {
  60                 logger.log(Level.FINEST, "firing loadingProjectsFailed event with [directory=" + directory + ",throwable=" + throwable + "]");
  61                 for (CoreListener coreListener : getListeners()) {
  62                         coreListener.loadingProjectsFailed(directory, throwable);
  63                 }
  64         }
  65
  66         /**
  67          * Notifies all listeners that the projects were successfully saved.
  68          *
  69          * @param directory
  70          *            The directory the projects were saved to
  71          */
  72         public void fireSavingProjectsDone(String directory) {
  73                 logger.log(Level.FINEST, "firing savingProjectsDone event with [directory=" + directory + "]");
  74                 for (CoreListener coreListener : getListeners()) {
  75                         coreListener.savingProjectsDone(directory);
  76                 }
  77         }
  78
  79         /**
  80          * Notifies all listeners that the projects could not be saved.
  81          *
  82          * @param directory
  83          *            The directory the projects were to be saved to
  84          * @param throwable
  85          *            The exception that occured when saving the projects
  86          */
  87         public void fireSavingProjectsFailed(String directory, Throwable throwable) {
  88                 logger.log(Level.FINEST, "firing savingProjectsFailed event with [directory=" + directory + ",throwable=" + throwable + "]");
  89                 for (CoreListener coreListener : getListeners()) {
  90                         coreListener.savingProjectsFailed(directory, throwable);
  91                 }
  92         }
  93
  94         /**
  95          * Notifies all listeners that a project was added.
  96          *
  97          * @param project
  98          *            The project that was added
  99          */
 100         public void fireProjectAdded(Project project) {
 101                 logger.log(Level.FINEST, "firing projectAdded event with [project=" + project + "]");
 102                 for (CoreListener coreListener : getListeners()) {
 103                         coreListener.projectAdded(project);
 104                 }
 105         }
 106
 107         /**
 108          * Notifies all listeners that a project was cloned.
 109          *
 110          * @param clonedProject
 111          *            The project that was cloned
 112          * @param projectClone
 113          *            The clone of the project
 114          */
 115         public void fireProjectCloned(Project clonedProject, Project projectClone) {
 116                 logger.log(Level.FINEST, "firing projectCloned event with [clonedProject=" + clonedProject + ",projectClone=" + projectClone + "]");
 117                 for (CoreListener coreListener : getListeners()) {
 118                         coreListener.projectCloned(clonedProject, projectClone);
 119                 }
 120         }
 121
 122         /**
 123          * Notifies all listeners that a project was removed.
 124          *
 125          * @param project
 126          *            The project that was removed
 127          */
 128         public void fireProjectRemoved(Project project) {
 129                 logger.log(Level.FINEST, "firing projectRemoved event with [project=" + project + "]");
 130                 for (CoreListener coreListener : getListeners()) {
 131                         coreListener.projectRemoved(project);
 132                 }
 133         }
 134
 135         /**
 136          * Notifies all listeners that the nodes were successfully loaded.
 137          *
 138          * @param directory
 139          *            The directory the nodes were loaded from
 140          */
 141         public void fireLoadingNodesDone(String directory) {
 142                 logger.log(Level.FINEST, "firing loadingNodesDone event with [directory=" + directory + "]");
 143                 for (CoreListener coreListener : getListeners()) {
 144                         coreListener.loadingNodesDone(directory);
 145                 }
 146         }
 147
 148         /**
 149          * Notifies all listeners that loading the nodes has failed.
 150          *
 151          * @param directory
 152          *            The directory the nodes were loaded from
 153          * @param throwable
 154          *            The exception that occured while loading the nodes
 155          */
 156         public void fireLoadingNodesFailed(String directory, Throwable throwable) {
 157                 logger.log(Level.FINEST, "firing loadingNodesFailed event with [directory=" + directory + ",throwable=" + throwable + "]");
 158                 for (CoreListener coreListener : getListeners()) {
 159                         coreListener.loadingNodesFailed(directory, throwable);
 160                 }
 161         }
 162
 163         /**
 164          * Notifies all listeners that the nodes were saved successfully.
 165          *
 166          * @param directory
 167          *            The directory the nodes were saved to
 168          */
 169         public void fireSavingNodesDone(String directory) {
 170                 logger.log(Level.FINEST, "firing savingNodesDone event with [directory=" + directory + "]");
 171                 for (CoreListener coreListener : getListeners()) {
 172                         coreListener.savingNodesDone(directory);
 173                 }
 174         }
 175
 176         /**
 177          * Notifies all listeners that saving the nodes has failed.
 178          *
 179          * @param directory
 180          *            The directory the nodes were saved to
 181          * @param throwable
 182          *            The exception that occured while saving the nodes
 183          */
 184         public void fireSavingNodesFailed(String directory, Throwable throwable) {
 185                 logger.log(Level.FINEST, "firing savingNodesFailed event with [directory=" + directory + ",throwable=" + throwable + "]");
 186                 for (CoreListener coreListener : getListeners()) {
 187                         coreListener.savingProjectsFailed(directory, throwable);
 188                 }
 189         }
 190
 191         /**
 192          * Notifies all core listeners that the core has loaded and is ready to run.
 193          */
 194         public void fireCoreLoaded() {
 195                 logger.log(Level.FINEST, "firing coreLoaded event");
 196                 for (CoreListener coreListener : getListeners()) {
 197                         coreListener.coreLoaded();
 198                 }
 199         }
 200
 201         /**
 202          * Notifies all listeners that the core was stopped.
 203          */
 204         public void fireCoreStopped() {
 205                 logger.log(Level.FINEST, "firing coreStopped event");
 206                 for (CoreListener coreListener : getListeners()) {
 207                         coreListener.coreStopped();
 208                 }
 209         }
 210
 211         /**
 212          * Notifies all listeners that a node was added to the core.
 213          *
 214          * @param node
 215          *            The node that was added
 216          */
 217         public void fireNodeAdded(Node node) {
 218                 logger.log(Level.FINEST, "firing nodeAdded event with [node=" + node + "]");
 219                 for (CoreListener coreListener : getListeners()) {
 220                         coreListener.nodeAdded(node);
 221                 }
 222         }
 223
 224         /**
 225          * Notifies all listeners that a node was removed from the core.
 226          *
 227          * @param node
 228          *            The node that was removed
 229          */
 230         public void fireNodeRemoved(Node node) {
 231                 logger.log(Level.FINEST, "firing nodeRemoved event with [node=" + node + "]");
 232                 for (CoreListener coreListener : getListeners()) {
 233                         coreListener.nodeRemoved(node);
 234                 }
 235         }
 236
 237         /**
 238          * Notifies all listeners that a connection to the given node is now being
 239          * established.
 240          *
 241          * @param node
 242          *            The node that is being connected to
 243          */
 244         public void fireNodeConnecting(Node node) {
 245                 logger.log(Level.FINEST, "firing nodeConnecting event with [node=" + node + "]");
 246                 for (CoreListener coreListener : getListeners()) {
 247                         coreListener.nodeConnecting(node);
 248                 }
 249         }
 250
 251         /**
 252          * Notifies all listeners that the given node is now connected.
 253          *
 254          * @param node
 255          *            The node that is now connected
 256          */
 257         public void fireNodeConnected(Node node) {
 258                 logger.log(Level.FINEST, "firing nodeConnected event with [node=" + node + "]");
 259                 for (CoreListener coreListener : getListeners()) {
 260                         coreListener.nodeConnected(node);
 261                 }
 262         }
 263
 264         /**
 265          * Notifies all listeners that a connection to a node has failed.
 266          *
 267          * @param node
 268          *            The node that could not be connected
 269          * @param cause
 270          *            The cause of the failure
 271          */
 272         public void fireNodeConnectionFailed(Node node, Throwable cause) {
 273                 logger.log(Level.FINEST, "firing nodeConnectionFailed event with [node=" + node + ",cause=" + cause + "]");
 274                 for (CoreListener coreListener : getListeners()) {
 275                         coreListener.nodeConnectionFailed(node, cause);
 276                 }
 277         }
 278
 279         /**
 280          * Notifies all listeners that the given node was disconnected.
 281          *
 282          * @param node
 283          *            The node that is now disconnected
 284          * @param throwable
 285          *            The exception that caused the disconnect, or <code>null</code>
 286          *            if there was no exception
 287          */
 288         public void fireNodeDisconnected(Node node, Throwable throwable) {
 289                 logger.log(Level.FINEST, "firing nodeDisconnected event with [node=" + node + ",throwable=" + throwable + "]");
 290                 for (CoreListener coreListener : getListeners()) {
 291                         coreListener.nodeDisconnected(node, throwable);
 292                 }
 293         }
 294
 295 }