src/main/java/net/pterodactylus/fcp/FcpListenerManager.java

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