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