vendor/swiftmailer/swiftmailer/lib/classes/Swift/Events/SimpleEventDispatcher.php line 81

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of SwiftMailer.
  5.  * (c) 2004-2009 Chris Corbyn
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  11. /**
  12.  * The EventDispatcher which handles the event dispatching layer.
  13.  *
  14.  * @author Chris Corbyn
  15.  */
  16. class Swift_Events_SimpleEventDispatcher implements Swift_Events_EventDispatcher
  17. {
  18.     /** A map of event types to their associated listener types */
  19.     private $eventMap = [];
  21.     /** Event listeners bound to this dispatcher */
  22.     private $listeners = [];
  24.     /**
  25.      * Create a new EventDispatcher.
  26.      */
  27.     public function __construct()
  28.     {
  29.         $this->eventMap = [
  30.             'Swift_Events_CommandEvent' => 'Swift_Events_CommandListener',
  31.             'Swift_Events_ResponseEvent' => 'Swift_Events_ResponseListener',
  32.             'Swift_Events_SendEvent' => 'Swift_Events_SendListener',
  33.             'Swift_Events_TransportChangeEvent' => 'Swift_Events_TransportChangeListener',
  34.             'Swift_Events_TransportExceptionEvent' => 'Swift_Events_TransportExceptionListener',
  35.             ];
  36.     }
  38.     /**
  39.      * Create a new SendEvent for $source and $message.
  40.      *
  41.      * @return Swift_Events_SendEvent
  42.      */
  43.     public function createSendEvent(Swift_Transport $source, Swift_Mime_SimpleMessage $message)
  44.     {
  45.         return new Swift_Events_SendEvent($source, $message);
  46.     }
  48.     /**
  49.      * Create a new CommandEvent for $source and $command.
  50.      *
  51.      * @param string $command      That will be executed
  52.      * @param array  $successCodes That are needed
  53.      *
  54.      * @return Swift_Events_CommandEvent
  55.      */
  56.     public function createCommandEvent(Swift_Transport $source, $command, $successCodes = [])
  57.     {
  58.         return new Swift_Events_CommandEvent($source, $command, $successCodes);
  59.     }
  61.     /**
  62.      * Create a new ResponseEvent for $source and $response.
  63.      *
  64.      * @param string $response
  65.      * @param bool   $valid    If the response is valid
  66.      *
  67.      * @return Swift_Events_ResponseEvent
  68.      */
  69.     public function createResponseEvent(Swift_Transport $source, $response, $valid)
  70.     {
  71.         return new Swift_Events_ResponseEvent($source, $response, $valid);
  72.     }
  74.     /**
  75.      * Create a new TransportChangeEvent for $source.
  76.      *
  77.      * @return Swift_Events_TransportChangeEvent
  78.      */
  79.     public function createTransportChangeEvent(Swift_Transport $source)
  80.     {
  81.         return new Swift_Events_TransportChangeEvent($source);
  82.     }
  84.     /**
  85.      * Create a new TransportExceptionEvent for $source.
  86.      *
  87.      * @return Swift_Events_TransportExceptionEvent
  88.      */
  89.     public function createTransportExceptionEvent(Swift_Transport $source, Swift_TransportException $ex)
  90.     {
  91.         return new Swift_Events_TransportExceptionEvent($source, $ex);
  92.     }
  94.     /**
  95.      * Bind an event listener to this dispatcher.
  96.      */
  97.     public function bindEventListener(Swift_Events_EventListener $listener)
  98.     {
  99.         foreach ($this->listeners as $l) {
  100.             // Already loaded
  101.             if ($l === $listener) {
  102.                 return;
  103.             }
  104.         }
  105.         $this->listeners[] = $listener;
  106.     }
  108.     /**
  109.      * Dispatch the given Event to all suitable listeners.
  110.      *
  111.      * @param string $target method
  112.      */
  113.     public function dispatchEvent(Swift_Events_EventObject $evt, $target)
  114.     {
  115.         $bubbleQueue = $this->prepareBubbleQueue($evt);
  116.         $this->bubble($bubbleQueue, $evt, $target);
  117.     }
  119.     /** Queue listeners on a stack ready for $evt to be bubbled up it */
  120.     private function prepareBubbleQueue(Swift_Events_EventObject $evt)
  121.     {
  122.         $bubbleQueue = [];
  123.         $evtClass = \get_class($evt);
  124.         foreach ($this->listeners as $listener) {
  125.             if (\array_key_exists($evtClass, $this->eventMap)
  126.                 && ($listener instanceof $this->eventMap[$evtClass])) {
  127.                 $bubbleQueue[] = $listener;
  128.             }
  129.         }
  131.         return $bubbleQueue;
  132.     }
  134.     /** Bubble $evt up the stack calling $target() on each listener */
  135.     private function bubble(array &$bubbleQueue, Swift_Events_EventObject $evt, $target)
  136.     {
  137.         if (!$evt->bubbleCancelled() && $listener = array_shift($bubbleQueue)) {
  138.             $listener->$target($evt);
  139.             $this->bubble($bubbleQueue, $evt, $target);
  140.         }
  141.     }
  142. }