src/net/pterodactylus/fcp/FcpListenerManager.java

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