src/main/java/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          *            The “PeerNote” message
 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
 295          * received.
 296          *
 297          * @see FcpListener#receivedFinishedCompression(FcpConnection,
 298          *      FinishedCompression)
 299          * @param finishedCompression
 300          *            The “FinishedCompression” message
 301          */
 302         public void fireReceivedFinishedCompression(FinishedCompression finishedCompression) {
 303                 for (FcpListener fcpListener : getListeners()) {
 304                         fcpListener.receivedFinishedCompression(getSource(), finishedCompression);
 305                 }
 306         }
 307
 308         /**
 309          * Notifies all listeners that an “UnknownPeerNoteType” message was
 310          * received.
 311          *
 312          * @see FcpListener#receivedUnknownPeerNoteType(FcpConnection,
 313          *      UnknownPeerNoteType)
 314          * @param unknownPeerNoteType
 315          *            The “UnknownPeerNoteType” message
 316          */
 317         public void fireReceivedUnknownPeerNoteType(UnknownPeerNoteType unknownPeerNoteType) {
 318                 for (FcpListener fcpListener : getListeners()) {
 319                         fcpListener.receivedUnknownPeerNoteType(getSource(), unknownPeerNoteType);
 320                 }
 321         }
 322
 323         /**
 324          * Notifies all listeners that an “UnknownNodeIdentifier” message was
 325          * received.
 326          *
 327          * @see FcpListener#receivedUnknownNodeIdentifier(FcpConnection,
 328          *      UnknownNodeIdentifier)
 329          * @param unknownNodeIdentifier
 330          *            The “UnknownNodeIdentifier” message
 331          */
 332         public void fireReceivedUnknownNodeIdentifier(UnknownNodeIdentifier unknownNodeIdentifier) {
 333                 for (FcpListener fcpListener : getListeners()) {
 334                         fcpListener.receivedUnknownNodeIdentifier(getSource(), unknownNodeIdentifier);
 335                 }
 336         }
 337
 338         /**
 339          * Notifies all listeners that a “ConfigData” message was received.
 340          *
 341          * @see FcpListener#receivedConfigData(FcpConnection, ConfigData)
 342          * @param configData
 343          *            The “ConfigData” message
 344          */
 345         public void fireReceivedConfigData(ConfigData configData) {
 346                 for (FcpListener fcpListener : getListeners()) {
 347                         fcpListener.receivedConfigData(getSource(), configData);
 348                 }
 349         }
 350
 351         /**
 352          * Notifies all listeners that a “GetFailed” message was received.
 353          *
 354          * @see FcpListener#receivedGetFailed(FcpConnection, GetFailed)
 355          * @param getFailed
 356          *            The “GetFailed” message
 357          */
 358         public void fireReceivedGetFailed(GetFailed getFailed) {
 359                 for (FcpListener fcpListener : getListeners()) {
 360                         fcpListener.receivedGetFailed(getSource(), getFailed);
 361                 }
 362         }
 363
 364         /**
 365          * Notifies all listeners that a “PutFailed” message was received.
 366          *
 367          * @see FcpListener#receivedPutFailed(FcpConnection, PutFailed)
 368          * @param putFailed
 369          *            The “PutFailed” message
 370          */
 371         public void fireReceivedPutFailed(PutFailed putFailed) {
 372                 for (FcpListener fcpListener : getListeners()) {
 373                         fcpListener.receivedPutFailed(getSource(), putFailed);
 374                 }
 375         }
 376
 377         /**
 378          * Notifies all listeners that an “IdentifierCollision” message was
 379          * received.
 380          *
 381          * @see FcpListener#receivedIdentifierCollision(FcpConnection,
 382          *      IdentifierCollision)
 383          * @param identifierCollision
 384          *            The “IdentifierCollision” message
 385          */
 386         public void fireReceivedIdentifierCollision(IdentifierCollision identifierCollision) {
 387                 for (FcpListener fcpListener : getListeners()) {
 388                         fcpListener.receivedIdentifierCollision(getSource(), identifierCollision);
 389                 }
 390         }
 391
 392         /**
 393          * Notifies all listeners that an “PersistentPutDir” message was received.
 394          *
 395          * @see FcpListener#receivedPersistentPutDir(FcpConnection,
 396          *      PersistentPutDir)
 397          * @param persistentPutDir
 398          *            The “PersistentPutDir” message
 399          */
 400         public void fireReceivedPersistentPutDir(PersistentPutDir persistentPutDir) {
 401                 for (FcpListener fcpListener : getListeners()) {
 402                         fcpListener.receivedPersistentPutDir(getSource(), persistentPutDir);
 403                 }
 404         }
 405
 406         /**
 407          * Notifies all listeners that a “PersistentRequestRemoved” message was
 408          * received.
 409          *
 410          * @see FcpListener#receivedPersistentRequestRemoved(FcpConnection,
 411          *      PersistentRequestRemoved)
 412          * @param persistentRequestRemoved
 413          *            The “PersistentRequestRemoved” message
 414          */
 415         public void fireReceivedPersistentRequestRemoved(PersistentRequestRemoved persistentRequestRemoved) {
 416                 for (FcpListener fcpListener : getListeners()) {
 417                         fcpListener.receivedPersistentRequestRemoved(getSource(), persistentRequestRemoved);
 418                 }
 419         }
 420
 421         /**
 422          * Notifies all listeners that a “SubscribedUSKUpdate” message was
 423          * received.
 424          *
 425          * @see FcpListener#receivedSubscribedUSKUpdate(FcpConnection,
 426          *      SubscribedUSKUpdate)
 427          * @param subscribedUSKUpdate
 428          *            The “SubscribedUSKUpdate” message
 429          */
 430         public void fireReceivedSubscribedUSKUpdate(SubscribedUSKUpdate subscribedUSKUpdate) {
 431                 for (FcpListener fcpListener : getListeners()) {
 432                         fcpListener.receivedSubscribedUSKUpdate(getSource(), subscribedUSKUpdate);
 433                 }
 434         }
 435
 436         /**
 437          * Notifies all listeners that a “PluginInfo” message was received.
 438          *
 439          * @see FcpListener#receivedPluginInfo(FcpConnection, PluginInfo)
 440          * @param pluginInfo
 441          *            The “PluginInfo” message
 442          */
 443         public void fireReceivedPluginInfo(PluginInfo pluginInfo) {
 444                 for (FcpListener fcpListener : getListeners()) {
 445                         fcpListener.receivedPluginInfo(getSource(), pluginInfo);
 446                 }
 447         }
 448
 449         /**
 450          * Notifies all listeners that an “FCPPluginReply” message was received.
 451          *
 452          * @see FcpListener#receivedFCPPluginReply(FcpConnection, FCPPluginReply)
 453          * @param fcpPluginReply
 454          *            The “FCPPluginReply” message
 455          */
 456         public void fireReceivedFCPPluginReply(FCPPluginReply fcpPluginReply) {
 457                 for (FcpListener fcpListener : getListeners()) {
 458                         fcpListener.receivedFCPPluginReply(getSource(), fcpPluginReply);
 459                 }
 460         }
 461
 462         /**
 463          * Notifies all listeners that a “PersistentRequestModified” message was
 464          * received.
 465          *
 466          * @see FcpListener#receivedPersistentRequestModified(FcpConnection,
 467          *      PersistentRequestModified)
 468          * @param persistentRequestModified
 469          *            The “PersistentRequestModified” message
 470          */
 471         public void fireReceivedPersistentRequestModified(PersistentRequestModified persistentRequestModified) {
 472                 for (FcpListener fcpListener : getListeners()) {
 473                         fcpListener.receivedPersistentRequestModified(getSource(), persistentRequestModified);
 474                 }
 475         }
 476
 477         /**
 478          * Notifies all listeners that a “PutSuccessful” message was received.
 479          *
 480          * @see FcpListener#receivedPutSuccessful(FcpConnection, PutSuccessful)
 481          * @param putSuccessful
 482          *            The “PutSuccessful” message
 483          */
 484         public void fireReceivedPutSuccessful(PutSuccessful putSuccessful) {
 485                 for (FcpListener fcpListener : getListeners()) {
 486                         fcpListener.receivedPutSuccessful(getSource(), putSuccessful);
 487                 }
 488         }
 489
 490         /**
 491          * Notifies all listeners that a “PutFetchable” message was received.
 492          *
 493          * @see FcpListener#receivedPutFetchable(FcpConnection, PutFetchable)
 494          * @param putFetchable
 495          *            The “PutFetchable” message
 496          */
 497         public void fireReceivedPutFetchable(PutFetchable putFetchable) {
 498                 for (FcpListener fcpListener : getListeners()) {
 499                         fcpListener.receivedPutFetchable(getSource(), putFetchable);
 500                 }
 501         }
 502
 503         /**
 504          * Notifies all listeners that a “ProtocolError” message was received.
 505          *
 506          * @see FcpListener#receivedProtocolError(FcpConnection, ProtocolError)
 507          * @param protocolError
 508          *            The “ProtocolError” message
 509          */
 510         public void fireReceivedProtocolError(ProtocolError protocolError) {
 511                 for (FcpListener fcpListener : getListeners()) {
 512                         fcpListener.receivedProtocolError(getSource(), protocolError);
 513                 }
 514         }
 515
 516         /**
 517          * Notifies all listeners that a “SentFeed” message was received.
 518          *
 519          * @see FcpListener#receivedSentFeed(FcpConnection, SentFeed)
 520          * @param sentFeed
 521          *            The “SentFeed” message.
 522          */
 523         public void fireSentFeed(SentFeed sentFeed) {
 524                 for (FcpListener fcpListener : getListeners()) {
 525                         fcpListener.receivedSentFeed(getSource(), sentFeed);
 526                 }
 527         }
 528
 529         /**
 530          * Notifies all listeners that a “ReceivedBookmarkFeed” message was
 531          * received.
 532          *
 533          * @see FcpListener#receivedBookmarkFeed(FcpConnection,
 534          *      ReceivedBookmarkFeed)
 535          * @param receivedBookmarkFeed
 536          *            The “ReceivedBookmarkFeed” message
 537          */
 538         public void fireReceivedBookmarkFeed(ReceivedBookmarkFeed receivedBookmarkFeed) {
 539                 for (FcpListener fcpListener : getListeners()) {
 540                         fcpListener.receivedBookmarkFeed(getSource(), receivedBookmarkFeed);
 541                 }
 542         }
 543
 544         /**
 545          * Notifies all registered listeners that a message has been received.
 546          *
 547          * @see FcpListener#receivedMessage(FcpConnection, FcpMessage)
 548          * @param fcpMessage
 549          *            The message that was received
 550          */
 551         public void fireMessageReceived(FcpMessage fcpMessage) {
 552                 for (FcpListener fcpListener : getListeners()) {
 553                         fcpListener.receivedMessage(getSource(), fcpMessage);
 554                 }
 555         }
 556
 557         /**
 558          * Notifies all listeners that the connection to the node was closed.
 559          *
 560          * @param throwable
 561          *            The exception that caused the disconnect, or
 562          *            <code>null</code> if there was no exception
 563          * @see FcpListener#connectionClosed(FcpConnection, Throwable)
 564          */
 565         public void fireConnectionClosed(Throwable throwable) {
 566                 for (FcpListener fcpListener : getListeners()) {
 567                         fcpListener.connectionClosed(getSource(), throwable);
 568                 }
 569         }
 570
 571 }