PEIP_ABS_Interceptable_Message_Channel.php

Go to the documentation of this file.

<?php

/*
 * This file is part of the PEIP package.
 * (c) 2010 Timo Michna <timomichna/yahoo.de>
 * 
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
abstract class PEIP_ABS_Interceptable_Message_Channel 
    implements 
        PEIP_INF_Channel,
        PEIP_INF_Interceptable,
        PEIP_INF_Connectable {

    protected 
        $eventDispatcher,
        $interceptorDispatcher,
        $name,
        $interceptors = array();
    
    protected static 
        $sharedEventDispatcher; 

    
    public function __construct($name){
        $this->name = $name;
    }        
    
    public function getName(){
        return $this->name;
    }

    public function setInterceptorDispatcher(PEIP_Interceptor_Dispatcher $dispatcher){
        $this->interceptorDispatcher = $dispatcher;
    }
    
    
    public function getInterceptorDispatcher(){
        return is_object($this->interceptorDispatcher) ? $this->interceptorDispatcher : $this->interceptorDispatcher = new PEIP_Interceptor_Dispatcher();
    }   
    
    
    protected function dispatchInterceptor(PEIP_INF_Message $message, $eventName, array $parameters = array()){
        array_unshift($parameters, $message, $this); 
        return $this->getInterceptorDispatcher()->notify($eventName, $parameters);
    }
    
    
    public function send(PEIP_INF_Message $message, $timeout = -1){
        $this->dispatchInterceptor($message, 'preSend');
        $this->doFireEvent('preSend', array('MESSAGE'=>$message));
        $sent = $this->doSend($message);
        $this->dispatchInterceptor($message, 'postSend', array('sent' => $sent));
        $this->doFireEvent('postSend', array('MESSAGE'=>$message, 'SENT' => $sent));
    }

    
    abstract protected function doSend(PEIP_INF_Message $message);
    
    
    public function addInterceptor(PEIP_INF_Channel_Interceptor $interceptor){
        
        $hash = spl_object_hash($interceptor);
        $this->interceptors[$hash] = $interceptor;      
        $this->interceptorsHandlers[$hash] = array();
        foreach(array('preSend', 'postSend') as $event){
            $handler = new PEIP_Callable_Message_Handler(array($interceptor, $event));
            $this->connectInterceptor($event, $handler); 
            $this->interceptorsHandlers[$hash][$event]  = $handler;
        }
    }

    
    public function connectInterceptor($eventName, $handler){
        $this->getInterceptorDispatcher()->connect($eventName, $handler);   
    }
     
    public function deleteInterceptor(PEIP_INF_Channel_Interceptor $interceptor){
        $hash = spl_object_hash($interceptor);
        $handlers = $this->interceptorsHandlers[$hash];
        $this->getInterceptorDispatcher()->disconnect('preSend', $handlers['preSend']);
        $this->getInterceptorDispatcher()->disconnect('postSend', $handlers['postSend']);
        unset($this->interceptors[$hash]); 
        unset($this->interceptors[$hash]);
    }
    
    public function getInterceptors(){
        return array_values($this->interceptors);
    }
      
    public function setInterceptors(array $interceptors){
        $this->clearInterceptors();
        foreach($interceptors as $interceptor){
            $this->addInterceptor($interceptor);
        }
    }
         
    public function clearInterceptors(){
        foreach($this->interceptors as $interceptor){
            $this->deleteInterceptor($interceptor);
        }
    }
  
    public function connect($name, PEIP_INF_Handler $listener){
        $this->getEventDispatcher()->connect($name, $this, $listener);      
    }   
 
    public function disconnect($name, PEIP_INF_Handler $listener){
        $this->getEventDispatcher()->disconnect($name, $this, $listener);       
    }   
    
    public function hasListeners($name){
        return $this->getEventDispatcher()->hasListeners($name, $this);
    }
       
    public function getListeners($name){
        return $this->getEventDispatcher()->getListeners($name, $this);
    }
        
    public function setEventDispatcher(PEIP_Object_Event_Dispatcher $dispatcher, $transferListners = true){
        if($transferListners){
            foreach($this->eventDispatcher->getEventNames($this) as $name){
                if($this->eventDispatcher->hasListeners($name, $this)){
                    foreach($this->eventDispatcher->getListeners($name, $this) as $listener){
                        $dispatcher->connect($name, $this, $listener);  
                    }
                }       
            }   
        }   
        $this->eventDispatcher = $dispatcher;       
    }
       
    public function getEventDispatcher(){
        return $this->eventDispatcher ? $this->eventDispatcher : $this->eventDispatcher = self::getSharedEventDispatcher();
    }   

    protected static function getSharedEventDispatcher(){
        return self::$sharedEventDispatcher ? self::$sharedEventDispatcher : self::$sharedEventDispatcher = new PEIP_Object_Event_Dispatcher; 
    }
   
    protected function doFireEvent($name, array $headers = array(), $eventClass = false){
        return $this->getEventDispatcher()->buildAndNotify($name, $this, $headers, $eventClass);
    }
}

---