1 <?php

     2 

     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  */

    10 

    11 

    12 /**

    13  * The EventDispatcher which handles the event dispatching layer.

    14  * 

    15  * @package Swift

    16  * @subpackage Events

    17  * @author Chris Corbyn

    18  */

    19 class Swift_Events_SimpleEventDispatcher implements Swift_Events_EventDispatcher

    20 {

    21   

    22   /** A map of event types to their associated listener types */

    23   private $_eventMap = array();

    24   

    25   /** Event listeners bound to this dispatcher */

    26   private $_listeners = array();

    27   

    28   /** Listeners queued to have an Event bubbled up the stack to them */

    29   private $_bubbleQueue = array();

    30   

    31   /**

    32    * Create a new EventDispatcher.

    33    */

    34   public function __construct()

    35   {

    36     $this->_eventMap = array(

    37       'Swift_Events_CommandEvent' => 'Swift_Events_CommandListener',

    38       'Swift_Events_ResponseEvent' => 'Swift_Events_ResponseListener',

    39       'Swift_Events_SendEvent' => 'Swift_Events_SendListener',

    40       'Swift_Events_TransportChangeEvent' => 'Swift_Events_TransportChangeListener',

    41       'Swift_Events_TransportExceptionEvent' => 'Swift_Events_TransportExceptionListener'

    42       );

    43   }

    44   

    45   /**

    46    * Create a new SendEvent for $source and $message.

    47    * 

    48    * @param Swift_Transport $source

    49    * @param Swift_Mime_Message

    50    * @return Swift_Events_SendEvent

    51    */

    52   public function createSendEvent(Swift_Transport $source,

    53     Swift_Mime_Message $message)

    54   {

    55     return new Swift_Events_SendEvent($source, $message);

    56   }

    57   

    58   /**

    59    * Create a new CommandEvent for $source and $command.

    60    * 

    61    * @param Swift_Transport $source

    62    * @param string $command That will be executed

    63    * @param array $successCodes That are needed

    64    * @return Swift_Events_CommandEvent

    65    */

    66   public function createCommandEvent(Swift_Transport $source,

    67     $command, $successCodes = array())

    68   {

    69     return new Swift_Events_CommandEvent($source, $command, $successCodes);

    70   }

    71   

    72   /**

    73    * Create a new ResponseEvent for $source and $response.

    74    * 

    75    * @param Swift_Transport $source

    76    * @param string $response

    77    * @param boolean $valid If the response is valid

    78    * @return Swift_Events_ResponseEvent

    79    */

    80   public function createResponseEvent(Swift_Transport $source,

    81     $response, $valid)

    82   {

    83     return new Swift_Events_ResponseEvent($source, $response, $valid);

    84   }

    85   

    86   /**

    87    * Create a new TransportChangeEvent for $source.

    88    * 

    89    * @param Swift_Transport $source

    90    * @return Swift_Events_TransportChangeEvent

    91    */

    92   public function createTransportChangeEvent(Swift_Transport $source)

    93   {

    94     return new Swift_Events_TransportChangeEvent($source);

    95   }

    96   

    97   /**

    98    * Create a new TransportExceptionEvent for $source.

    99    * 

   100    * @param Swift_Transport $source

   101    * @param Swift_TransportException $ex

   102    * @return Swift_Events_TransportExceptionEvent

   103    */

   104   public function createTransportExceptionEvent(Swift_Transport $source,

   105     Swift_TransportException $ex)

   106   {

   107     return new Swift_Events_TransportExceptionEvent($source, $ex);

   108   }

   109   

   110   /**

   111    * Bind an event listener to this dispatcher.

   112    * 

   113    * @param Swift_Events_EventListener $listener

   114    */

   115   public function bindEventListener(Swift_Events_EventListener $listener)

   116   {

   117     foreach ($this->_listeners as $l)

   118     {

   119       //Already loaded

   120       if ($l === $listener)

   121       {

   122         return;

   123       }

   124     }

   125     $this->_listeners[] = $listener;

   126   }

   127   

   128   /**

   129    * Dispatch the given Event to all suitable listeners.

   130    * 

   131    * @param Swift_Events_EventObject $evt

   132    * @param string $target method

   133    */

   134   public function dispatchEvent(Swift_Events_EventObject $evt, $target)

   135   {

   136     $this->_prepareBubbleQueue($evt);

   137     $this->_bubble($evt, $target);

   138   }

   139   

   140   // -- Private methods

   141   

   142   /** Queue listeners on a stack ready for $evt to be bubbled up it */

   143   private function _prepareBubbleQueue(Swift_Events_EventObject $evt)

   144   {

   145     $this->_bubbleQueue = array();

   146     $evtClass = get_class($evt);

   147     foreach ($this->_listeners as $listener)

   148     {

   149       if (array_key_exists($evtClass, $this->_eventMap)

   150         && ($listener instanceof $this->_eventMap[$evtClass]))

   151       {

   152         $this->_bubbleQueue[] = $listener;

   153       }

   154     }

   155   }

   156   

   157   /** Bubble $evt up the stack calling $target() on each listener */

   158   private function _bubble(Swift_Events_EventObject $evt, $target)

   159   {

   160     if (!$evt->bubbleCancelled() && $listener = array_shift($this->_bubbleQueue))

   161     {

   162       $listener->$target($evt);

   163       $this->_bubble($evt, $target);

   164     }

   165   }

   166   

   167 }