src/net/pterodactylus/fcp/FcpListenerManager.java

   1 /*
   2  * jFCPlib - FcpListenerManager.java -
   3  * Copyright © 2009 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.fcp;
  21
  22 import net.pterodactylus.util.event.AbstractListenerManager;
  23
  24 /**
  25  * Manages FCP listeners and event firing.
  26  *
  27  * @author David ‘Bombe’ Roden &lt;bombe@pterodactylus.net&gt;
  28  */
  29 public class FcpListenerManager extends AbstractListenerManager<FcpConnection, FcpListener> {
  30
  31         /**
  32          * Creates a new listener manager.
  33          *
  34          * @param fcpConnection
  35          *            The source FCP connection
  36          */
  37         public FcpListenerManager(FcpConnection fcpConnection) {
  38                 super(fcpConnection);
  39         }
  40
  41         /**
  42          * Notifies listeners that a “NodeHello” message was received.
  43          *
  44          * @see FcpListener#receivedNodeHello(FcpConnection, NodeHello)
  45          * @param nodeHello
  46          *            The “NodeHello” message
  47          */
  48         public void fireReceivedNodeHello(NodeHello nodeHello) {
  49                 for (FcpListener fcpListener : getListeners()) {
  50                         fcpListener.receivedNodeHello(getSource(), nodeHello);
  51                 }
  52         }
  53
  54         /**
  55          * Notifies listeners that a “CloseConnectionDuplicateClientName” message
  56          * was received.
  57          *
  58          * @see FcpListener#receivedCloseConnectionDuplicateClientName(FcpConnection,
  59          *      CloseConnectionDuplicateClientName)
  60          * @param closeConnectionDuplicateClientName
  61          *            The “CloseConnectionDuplicateClientName” message
  62          */
  63         public void fireReceivedCloseConnectionDuplicateClientName(CloseConnectionDuplicateClientName closeConnectionDuplicateClientName) {
  64                 for (FcpListener fcpListener : getListeners()) {
  65                         fcpListener.receivedCloseConnectionDuplicateClientName(getSource(), closeConnectionDuplicateClientName);
  66                 }
  67         }
  68
  69         /**
  70          * Notifies listeners that a “SSKKeypair” message was received.
  71          *
  72          * @see FcpListener#receivedSSKKeypair(FcpConnection, SSKKeypair)
  73          * @param sskKeypair
  74          *            The “SSKKeypair” message
  75          */
  76         public void fireReceivedSSKKeypair(SSKKeypair sskKeypair) {
  77                 for (FcpListener fcpListener : getListeners()) {
  78                         fcpListener.receivedSSKKeypair(getSource(), sskKeypair);
  79                 }
  80         }
  81
  82         /**
  83          * Notifies listeners that a “Peer” message was received.
  84          *
  85          * @see FcpListener#receivedPeer(FcpConnection, Peer)
  86          * @param peer
  87          *            The “Peer” message
  88          */
  89         public void fireReceivedPeer(Peer peer) {
  90                 for (FcpListener fcpListener : getListeners()) {
  91                         fcpListener.receivedPeer(getSource(), peer);
  92                 }
  93         }
  94
  95         /**
  96          * Notifies all listeners that an “EndListPeers” message was received.
  97          *
  98          * @see FcpListener#receivedEndListPeers(FcpConnection, EndListPeers)
  99          * @param endListPeers
 100          *            The “EndListPeers” message
 101          */
 102         public void fireReceivedEndListPeers(EndListPeers endListPeers) {
 103                 for (FcpListener fcpListener : getListeners()) {
 104                         fcpListener.receivedEndListPeers(getSource(), endListPeers);
 105                 }
 106         }
 107
 108         /**
 109          * Notifies all listeners that a “PeerNote” message was received.
 110          *
 111          * @see FcpListener#receivedPeerNote(FcpConnection, PeerNote)
 112          * @param peerNote
 113          */
 114         public void fireReceivedPeerNote(PeerNote peerNote) {
 115                 for (FcpListener fcpListener : getListeners()) {
 116                         fcpListener.receivedPeerNote(getSource(), peerNote);
 117                 }
 118         }
 119
 120         /**
 121          * Notifies all listeners that an “EndListPeerNotes” message was received.
 122          *
 123          * @see FcpListener#receivedEndListPeerNotes(FcpConnection,
 124          *      EndListPeerNotes)
 125          * @param endListPeerNotes
 126          *            The “EndListPeerNotes” message
 127          */
 128         public void fireReceivedEndListPeerNotes(EndListPeerNotes endListPeerNotes) {
 129                 for (FcpListener fcpListener : getListeners()) {
 130                         fcpListener.receivedEndListPeerNotes(getSource(), endListPeerNotes);
 131                 }
 132         }
 133
 134         /**
 135          * Notifies all listeners that a “PeerRemoved” message was received.
 136          *
 137          * @see FcpListener#receivedPeerRemoved(FcpConnection, PeerRemoved)
 138          * @param peerRemoved
 139          *            The “PeerRemoved” message
 140          */
 141         public void fireReceivedPeerRemoved(PeerRemoved peerRemoved) {
 142                 for (FcpListener fcpListener : getListeners()) {
 143                         fcpListener.receivedPeerRemoved(getSource(), peerRemoved);
 144                 }
 145         }
 146
 147         /**
 148          * Notifies all listeners that a “NodeData” message was received.
 149          *
 150          * @see FcpListener#receivedNodeData(FcpConnection, NodeData)
 151          * @param nodeData
 152          *            The “NodeData” message
 153          */
 154         public void fireReceivedNodeData(NodeData nodeData) {
 155                 for (FcpListener fcpListener : getListeners()) {
 156                         fcpListener.receivedNodeData(getSource(), nodeData);
 157                 }
 158         }
 159
 160         /**
 161          * Notifies all listeners that a “TestDDAReply” message was received.
 162          *
 163          * @see FcpListener#receivedTestDDAReply(FcpConnection, TestDDAReply)
 164          * @param testDDAReply
 165          *            The “TestDDAReply” message
 166          */
 167         public void fireReceivedTestDDAReply(TestDDAReply testDDAReply) {
 168                 for (FcpListener fcpListener : getListeners()) {
 169                         fcpListener.receivedTestDDAReply(getSource(), testDDAReply);
 170                 }
 171         }
 172
 173         /**
 174          * Notifies all listeners that a “TestDDAComplete” message was received.
 175          *
 176          * @see FcpListener#receivedTestDDAComplete(FcpConnection, TestDDAComplete)
 177          * @param testDDAComplete
 178          *            The “TestDDAComplete” message
 179          */
 180         public void fireReceivedTestDDAComplete(TestDDAComplete testDDAComplete) {
 181                 for (FcpListener fcpListener : getListeners()) {
 182                         fcpListener.receivedTestDDAComplete(getSource(), testDDAComplete);
 183                 }
 184         }
 185
 186         /**
 187          * Notifies all listeners that a “PersistentGet” message was received.
 188          *
 189          * @see FcpListener#receivedPersistentGet(FcpConnection, PersistentGet)
 190          * @param persistentGet
 191          *            The “PersistentGet” message
 192          */
 193         public void fireReceivedPersistentGet(PersistentGet persistentGet) {
 194                 for (FcpListener fcpListener : getListeners()) {
 195                         fcpListener.receivedPersistentGet(getSource(), persistentGet);
 196                 }
 197         }
 198
 199         /**
 200          * Notifies all listeners that a “PersistentPut” message was received.
 201          *
 202          * @see FcpListener#receivedPersistentPut(FcpConnection, PersistentPut)
 203          * @param persistentPut
 204          *            The “PersistentPut” message
 205          */
 206         public void fireReceivedPersistentPut(PersistentPut persistentPut) {
 207                 for (FcpListener fcpListener : getListeners()) {
 208                         fcpListener.receivedPersistentPut(getSource(), persistentPut);
 209                 }
 210         }
 211
 212         /**
 213          * Notifies all listeners that a “EndListPersistentRequests” message was
 214          * received.
 215          *
 216          * @see FcpListener#receivedEndListPersistentRequests(FcpConnection,
 217          *      EndListPersistentRequests)
 218          * @param endListPersistentRequests
 219          *            The “EndListPersistentRequests” message
 220          */
 221         public void fireReceivedEndListPersistentRequests(EndListPersistentRequests endListPersistentRequests) {
 222                 for (FcpListener fcpListener : getListeners()) {
 223                         fcpListener.receivedEndListPersistentRequests(getSource(), endListPersistentRequests);
 224                 }
 225         }
 226
 227         /**
 228          * Notifies all listeners that a “URIGenerated” message was received.
 229          *
 230          * @see FcpListener#receivedURIGenerated(FcpConnection, URIGenerated)
 231          * @param uriGenerated
 232          *            The “URIGenerated” message
 233          */
 234         public void fireReceivedURIGenerated(URIGenerated uriGenerated) {
 235                 for (FcpListener fcpListener : getListeners()) {
 236                         fcpListener.receivedURIGenerated(getSource(), uriGenerated);
 237                 }
 238         }
 239
 240         /**
 241          * Notifies all listeners that a “DataFound” message was received.
 242          *
 243          * @see FcpListener#receivedDataFound(FcpConnection, DataFound)
 244          * @param dataFound
 245          *            The “DataFound” message
 246          */
 247         public void fireReceivedDataFound(DataFound dataFound) {
 248                 for (FcpListener fcpListener : getListeners()) {
 249                         fcpListener.receivedDataFound(getSource(), dataFound);
 250                 }
 251         }
 252
 253         /**
 254          * Notifies all listeners that an “AllData” message was received.
 255          *
 256          * @see FcpListener#receivedAllData(FcpConnection, AllData)
 257          * @param allData
 258          *            The “AllData” message
 259          */
 260         public void fireReceivedAllData(AllData allData) {
 261                 for (FcpListener fcpListener : getListeners()) {
 262                         fcpListener.receivedAllData(getSource(), allData);
 263                 }
 264         }
 265
 266         /**
 267          * Notifies all listeners that a “SimpleProgress” message was received.
 268          *
 269          * @see FcpListener#receivedSimpleProgress(FcpConnection, SimpleProgress)
 270          * @param simpleProgress
 271          *            The “SimpleProgress” message
 272          */
 273         public void fireReceivedSimpleProgress(SimpleProgress simpleProgress) {
 274                 for (FcpListener fcpListener : getListeners()) {
 275                         fcpListener.receivedSimpleProgress(getSource(), simpleProgress);
 276                 }
 277         }
 278
 279         /**
 280          * Notifies all listeners that a “StartedCompression” message was received.
 281          *
 282          * @see FcpListener#receivedStartedCompression(FcpConnection,
 283          *      StartedCompression)
 284          * @param startedCompression
 285          *            The “StartedCompression” message
 286          */
 287         public void fireReceivedStartedCompression(StartedCompression startedCompression) {
 288                 for (FcpListener fcpListener : getListeners()) {
 289                         fcpListener.receivedStartedCompression(getSource(), startedCompression);
 290                 }
 291         }
 292
 293         /**
 294          * Notifies all listeners that a “FinishedCompression” message was received.
 295          *
 296          * @see FcpListener#receivedFinishedCompression(FcpConnection,
 297          *      FinishedCompression)
 298          * @param finishedCompression
 299          *            The “FinishedCompression” message
 300          */
 301         public void fireReceivedFinishedCompression(FinishedCompression finishedCompression) {
 302                 for (FcpListener fcpListener : getListeners()) {
 303                         fcpListener.receivedFinishedCompression(getSource(), finishedCompression);
 304                 }
 305         }
 306
 307         /**
 308          * Notifies all listeners that an “UnknownPeerNoteType” message was
 309          * received.
 310          *
 311          * @see FcpListener#receivedUnknownPeerNoteType(FcpConnection,
 312          *      UnknownPeerNoteType)
 313          * @param unknownPeerNoteType
 314          *            The “UnknownPeerNoteType” message
 315          */
 316         public void fireReceivedUnknownPeerNoteType(UnknownPeerNoteType unknownPeerNoteType) {
 317                 for (FcpListener fcpListener : getListeners()) {
 318                         fcpListener.receivedUnknownPeerNoteType(getSource(), unknownPeerNoteType);
 319                 }
 320         }
 321
 322         /**
 323          * Notifies all listeners that an “UnknownNodeIdentifier” message was
 324          * received.
 325          *
 326          * @see FcpListener#receivedUnknownNodeIdentifier(FcpConnection,
 327          *      UnknownNodeIdentifier)
 328          * @param unknownNodeIdentifier
 329          *            The “UnknownNodeIdentifier” message
 330          */
 331         public void fireReceivedUnknownNodeIdentifier(UnknownNodeIdentifier unknownNodeIdentifier) {
 332                 for (FcpListener fcpListener : getListeners()) {
 333                         fcpListener.receivedUnknownNodeIdentifier(getSource(), unknownNodeIdentifier);
 334                 }
 335         }
 336
 337         /**
 338          * Notifies all listeners that a “ConfigData” message was received.
 339          *
 340          * @see FcpListener#receivedConfigData(FcpConnection, ConfigData)
 341          * @param configData
 342          *            The “ConfigData” message
 343          */
 344         public void fireReceivedConfigData(ConfigData configData) {
 345                 for (FcpListener fcpListener : getListeners()) {
 346                         fcpListener.receivedConfigData(getSource(), configData);
 347                 }
 348         }
 349
 350         /**
 351          * Notifies all listeners that a “GetFailed” message was received.
 352          *
 353          * @see FcpListener#receivedGetFailed(FcpConnection, GetFailed)
 354          * @param getFailed
 355          *            The “GetFailed” message
 356          */
 357         public void fireReceivedGetFailed(GetFailed getFailed) {
 358                 for (FcpListener fcpListener : getListeners()) {
 359                         fcpListener.receivedGetFailed(getSource(), getFailed);
 360                 }
 361         }
 362
 363         /**
 364          * Notifies all listeners that a “PutFailed” message was received.
 365          *
 366          * @see FcpListener#receivedPutFailed(FcpConnection, PutFailed)
 367          * @param putFailed
 368          *            The “PutFailed” message
 369          */
 370         public void fireReceivedPutFailed(PutFailed putFailed) {
 371                 for (FcpListener fcpListener : getListeners()) {
 372                         fcpListener.receivedPutFailed(getSource(), putFailed);
 373                 }
 374         }
 375
 376         /**
 377          * Notifies all listeners that an “IdentifierCollision” message was
 378          * received.
 379          *
 380          * @see FcpListener#receivedIdentifierCollision(FcpConnection,
 381          *      IdentifierCollision)
 382          * @param identifierCollision
 383          *            The “IdentifierCollision” message
 384          */
 385         public void fireReceivedIdentifierCollision(IdentifierCollision identifierCollision) {
 386                 for (FcpListener fcpListener : getListeners()) {
 387                         fcpListener.receivedIdentifierCollision(getSource(), identifierCollision);
 388                 }
 389         }
 390
 391         /**
 392          * Notifies all listeners that an “PersistentPutDir” message was received.
 393          *
 394          * @see FcpListener#receivedPersistentPutDir(FcpConnection,
 395          *      PersistentPutDir)
 396          * @param persistentPutDir
 397          *            The “PersistentPutDir” message
 398          */
 399         public void fireReceivedPersistentPutDir(PersistentPutDir persistentPutDir) {
 400                 for (FcpListener fcpListener : getListeners()) {
 401                         fcpListener.receivedPersistentPutDir(getSource(), persistentPutDir);
 402                 }
 403         }
 404
 405         /**
 406          * Notifies all listeners that a “PersistentRequestRemoved” message was
 407          * received.
 408          *
 409          * @see FcpListener#receivedPersistentRequestRemoved(FcpConnection,
 410          *      PersistentRequestRemoved)
 411          * @param persistentRequestRemoved
 412          *            The “PersistentRequestRemoved” message
 413          */
 414         public void fireReceivedPersistentRequestRemoved(PersistentRequestRemoved persistentRequestRemoved) {
 415                 for (FcpListener fcpListener : getListeners()) {
 416                         fcpListener.receivedPersistentRequestRemoved(getSource(), persistentRequestRemoved);
 417                 }
 418         }
 419
 420         /**
 421          * Notifies all listeners that a “SubscribedUSKUpdate” message was received.
 422          *
 423          * @see FcpListener#receivedSubscribedUSKUpdate(FcpConnection,
 424          *      SubscribedUSKUpdate)
 425          * @param subscribedUSKUpdate
 426          *            The “SubscribedUSKUpdate” message
 427          */
 428         public void fireReceivedSubscribedUSKUpdate(SubscribedUSKUpdate subscribedUSKUpdate) {
 429                 for (FcpListener fcpListener : getListeners()) {
 430                         fcpListener.receivedSubscribedUSKUpdate(getSource(), subscribedUSKUpdate);
 431                 }
 432         }
 433
 434         /**
 435          * Notifies all listeners that a “PluginInfo” message was received.
 436          *
 437          * @see FcpListener#receivedPluginInfo(FcpConnection, PluginInfo)
 438          * @param pluginInfo
 439          *            The “PluginInfo” message
 440          */
 441         public void fireReceivedPluginInfo(PluginInfo pluginInfo) {
 442                 for (FcpListener fcpListener : getListeners()) {
 443                         fcpListener.receivedPluginInfo(getSource(), pluginInfo);
 444                 }
 445         }
 446
 447         /**
 448          * Notifies all listeners that an “FCPPluginReply” message was received.
 449          *
 450          * @see FcpListener#receivedFCPPluginReply(FcpConnection, FCPPluginReply)
 451          * @param fcpPluginReply
 452          *            The “FCPPluginReply” message
 453          */
 454         public void fireReceivedFCPPluginReply(FCPPluginReply fcpPluginReply) {
 455                 for (FcpListener fcpListener : getListeners()) {
 456                         fcpListener.receivedFCPPluginReply(getSource(), fcpPluginReply);
 457                 }
 458         }
 459
 460         /**
 461          * Notifies all listeners that a “PersistentRequestModified” message was
 462          * received.
 463          *
 464          * @see FcpListener#receivedPersistentRequestModified(FcpConnection,
 465          *      PersistentRequestModified)
 466          * @param persistentRequestModified
 467          *            The “PersistentRequestModified” message
 468          */
 469         public void fireReceivedPersistentRequestModified(PersistentRequestModified persistentRequestModified) {
 470                 for (FcpListener fcpListener : getListeners()) {
 471                         fcpListener.receivedPersistentRequestModified(getSource(), persistentRequestModified);
 472                 }
 473         }
 474
 475         /**
 476          * Notifies all listeners that a “PutSuccessful” message was received.
 477          *
 478          * @see FcpListener#receivedPutSuccessful(FcpConnection, PutSuccessful)
 479          * @param putSuccessful
 480          *            The “PutSuccessful” message
 481          */
 482         public void fireReceivedPutSuccessful(PutSuccessful putSuccessful) {
 483                 for (FcpListener fcpListener : getListeners()) {
 484                         fcpListener.receivedPutSuccessful(getSource(), putSuccessful);
 485                 }
 486         }
 487
 488         /**
 489          * Notifies all listeners that a “PutFetchable” message was received.
 490          *
 491          * @see FcpListener#receivedPutFetchable(FcpConnection, PutFetchable)
 492          * @param putFetchable
 493          *            The “PutFetchable” message
 494          */
 495         public void fireReceivedPutFetchable(PutFetchable putFetchable) {
 496                 for (FcpListener fcpListener : getListeners()) {
 497                         fcpListener.receivedPutFetchable(getSource(), putFetchable);
 498                 }
 499         }
 500
 501         /**
 502          * Notifies all listeners that a “ProtocolError” message was received.
 503          *
 504          * @see FcpListener#receivedProtocolError(FcpConnection, ProtocolError)
 505          * @param protocolError
 506          *            The “ProtocolError” message
 507          */
 508         public void fireReceivedProtocolError(ProtocolError protocolError) {
 509                 for (FcpListener fcpListener : getListeners()) {
 510                         fcpListener.receivedProtocolError(getSource(), protocolError);
 511                 }
 512         }
 513
 514         /**
 515          * Notifies all listeners that a “ReceivedBookmarkFeed” message was
 516          * received.
 517          *
 518          * @see FcpListener#receivedBookmarkFeed(FcpConnection,
 519          *      ReceivedBookmarkFeed)
 520          * @param receivedBookmarkFeed
 521          *            The “ReceivedBookmarkFeed” message
 522          */
 523         public void fireReceivedBookmarkFeed(ReceivedBookmarkFeed receivedBookmarkFeed) {
 524                 for (FcpListener fcpListener : getListeners()) {
 525                         fcpListener.receivedBookmarkFeed(getSource(), receivedBookmarkFeed);
 526                 }
 527         }
 528
 529         /**
 530          * Notifies all registered listeners that a message has been received.
 531          *
 532          * @see FcpListener#receivedMessage(FcpConnection, FcpMessage)
 533          * @param fcpMessage
 534          *            The message that was received
 535          */
 536         public void fireMessageReceived(FcpMessage fcpMessage) {
 537                 for (FcpListener fcpListener : getListeners()) {
 538                         fcpListener.receivedMessage(getSource(), fcpMessage);
 539                 }
 540         }
 541
 542         /**
 543          * Notifies all listeners that the connection to the node was closed.
 544          *
 545          * @param throwable
 546          *            The exception that caused the disconnect, or <code>null</code>
 547          *            if there was no exception
 548          * @see FcpListener#connectionClosed(FcpConnection, Throwable)
 549          */
 550         public void fireConnectionClosed(Throwable throwable) {
 551                 for (FcpListener fcpListener : getListeners()) {
 552                         fcpListener.connectionClosed(getSource(), throwable);
 553                 }
 554         }
 555
 556 }