Devil Killer Is Here MiNi Shell
MiNi SheLL

Current Path : /proc/thread-self/root/usr/local/lib/php-4.4.9/lib/php/Event/
Linux boscustweb5005.eigbox.net 5.4.91 #1 SMP Wed Jan 20 18:10:28 EST 2021 x86_64
Current File : //proc/thread-self/root/usr/local/lib/php-4.4.9/lib/php/Event/Dispatcher.php
<?php
// +-----------------------------------------------------------------------+
// | Copyright (c) 2005, Bertrand Mansion                                  |
// | All rights reserved.                                                  |
// |                                                                       |
// | Redistribution and use in source and binary forms, with or without    |
// | modification, are permitted provided that the following conditions    |
// | are met:                                                              |
// |                                                                       |
// | o Redistributions of source code must retain the above copyright      |
// |   notice, this list of conditions and the following disclaimer.       |
// | o Redistributions in binary form must reproduce the above copyright   |
// |   notice, this list of conditions and the following disclaimer in the |
// |   documentation and/or other materials provided with the distribution.|
// | o The names of the authors may not be used to endorse or promote      |
// |   products derived from this software without specific prior written  |
// |   permission.                                                         |
// |                                                                       |
// | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS   |
// | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT     |
// | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
// | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT  |
// | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
// | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT      |
// | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
// | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
// | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT   |
// | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
// | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  |
// |                                                                       |
// +-----------------------------------------------------------------------+
// | Author: Bertrand Mansion <bmansion@mamasam.com>                       |
// |         Stephan Schmidt <schst@php.net>                               |
// +-----------------------------------------------------------------------+
//
// $Id: Dispatcher.php 284686 2009-07-24 05:22:17Z clockwerx $

require_once 'Event/Notification.php';

/**
 * Pseudo 'static property' for Notification object
 * @global array $GLOBALS["_Event_Dispatcher"]
 */
$GLOBALS['_Event_Dispatcher'] = array(
                                  'NotificationClass' => 'Event_Notification'
                                     );

/**
 * Registers a global observer
 */
define('EVENT_DISPATCHER_GLOBAL', '');

/**
 * Dispatch notifications using PHP callbacks
 *
 * The Event_Dispatcher acts acts as a notification dispatch table.
 * It is used to notify other objects of interesting things, if
 * they meet certain criteria. This information is encapsulated 
 * in {@link Event_Notification} objects. Client objects register 
 * themselves with the Event_Dispatcher as observers of specific
 * notifications posted by other objects. When an event occurs,
 * an object posts an appropriate notification to the Event_Dispatcher.
 * The Event_Dispatcher dispatches a message to each
 * registered observer, passing the notification as the sole argument.
 *
 * The Event_Dispatcher is actually a combination of three design
 * patterns: the Singleton, {@link http://c2.com/cgi/wiki?MediatorPattern Mediator},
 * and Observer patterns. The idea behind Event_Dispatcher is borrowed from 
 * {@link http://developer.apple.com/documentation/Cocoa/Conceptual/Notifications/index.html Apple's Cocoa framework}.
 *
 * @category   Event
 * @package    Event_Dispatcher
 * @author     Bertrand Mansion <bmansion@mamasam.com>
 * @author     Stephan Schmidt <schst@php.net>
 * @copyright  1997-2005 The PHP Group
 * @license    http://www.opensource.org/licenses/bsd-license.php BSD License
 * @version    Release: @package_version@
 * @link       http://pear.php.net/package/Event_Dispatcher
 */
class Event_Dispatcher
{
    /**
     * Registered observer callbacks
     * @var array
     * @access private
     */
    var $_ro = array();
    
    /**
     * Pending notifications
     * @var array
     * @access private
     */
    var $_pending = array();

    /**
     * Nested observers
     * @var array
     * @access private
     */
    var $_nestedDispatchers = array();

    /**
     * Name of the dispatcher
     * @var string
     * @access private
     */
    var $_name = null;

    /**
     * Class used for notifications
     * @var string
     * @access private
     */
    var $_notificationClass = null;

    /**
     * PHP4 constructor
     *
     * Please use {@link getInstance()} instead.
     *
     * @access  private
     * @param   string      Name of the notification dispatcher.
     */
    function Event_Dispatcher($name)
    {
        Event_Dispatcher::__construct($name);
    }

    /**
     * PHP5 constructor
     *
     * Please use {@link getInstance()} instead.
     *
     * @access  private
     * @param   string      Name of the notification dispatcher.
     */
    function __construct($name)
    {
        $this->_name = $name;
        $this->_notificationClass = $GLOBALS['_Event_Dispatcher']['NotificationClass'];
    }

    /**
     * Returns a notification dispatcher singleton
     *
     * There is usually no need to have more than one notification
     * center for an application so this is the recommended way
     * to get a Event_Dispatcher object.
     *
     * @param string    Name of the notification dispatcher.
     *                  The default notification dispatcher is named __default.
     * 
     * @return object Event_Dispatcher
     */
    function &getInstance($name = '__default')
    {
        static $dispatchers = array();

        if (!isset($dispatchers[$name])) {
            $dispatchers[$name] = new Event_Dispatcher($name);
        }

        return $dispatchers[$name];
    }

    /**
     * Registers an observer callback
     *
     * This method registers a {@link http://www.php.net/manual/en/language.pseudo-types.php#language.types.callback callback}
     * which is called when the notification corresponding to the
     * criteria given at registration time is posted.
     * The criteria are the notification name and eventually the 
     * class of the object posted with the notification.
     *
     * If there are any pending notifications corresponding to the criteria
     * given here, the callback will be called straight away.
     *
     * If the notification name is empty, the observer will receive all the
     * posted notifications. Same goes for the class name.
     *
     * @access  public
     * @param   mixed       A PHP callback
     * @param   string      Expected notification name, serves as a filter
     * @param   string      Expected contained object class, serves as a filter
     * @return void
     */
    function addObserver($callback, $nName = EVENT_DISPATCHER_GLOBAL, $class = null)
    {
        if (is_array($callback)) {
            if (is_object($callback[0])) {
                // Note : PHP4 does not allow correct object comparison so
                // only the class name is used for registration checks.
                $reg = get_class($callback[0]).'::'.$callback[1];
            } else {
                $reg = $callback[0].'::'.$callback[1];
            }
        } else {
            $reg = $callback;
        }

        $this->_ro[$nName][$reg] = array(
                                    'callback' => $callback,
                                    'class'    => $class
                                    );

        // Post eventual pending notifications for this observer
        if (isset($this->_pending[$nName])) {
            foreach (array_keys($this->_pending[$nName]) as $k) {
                $notification =& $this->_pending[$nName][$k];
                if (!$notification->isNotificationCancelled()) {
                    $objClass = get_class($notification->getNotificationObject());
                    if (empty($class) || strcasecmp($class, $objClass) == 0) {
                        call_user_func_array($callback, array(&$notification));
                        $notification->increaseNotificationCount();
                    }
                }
            }
        }
    }

    /**
     * Creates and posts a notification object
     *
     * The purpose of the optional associated object is generally to pass
     * the object posting the notification to the observers, so that the 
     * observers can query the posting object for more information about
     * the event.
     *
     * Notifications are by default added to a pending notification list.
     * This way, if an observer is not registered by the time they are 
     * posted, it will still be notified when it is added as an observer.
     * This behaviour can be turned off in order to make sure that only
     * the registered observers will be notified.
     *
     * The info array serves as a container for any kind of useful 
     * information. It is added to the notification object and posted along.
     *
     * @access  public
     * @param   object      Notification associated object
     * @param   string      Notification name
     * @param   array       Optional user information
     * @param   bool        Whether the notification is pending
     * @param   bool        Whether you want the notification to bubble up
     * @return  object  The notification object
     */
    function &post(&$object, $nName, $info = array(), $pending = true, $bubble = true)
    {
        $notification =& new $this->_notificationClass($object, $nName, $info);
        return $this->postNotification($notification, $pending, $bubble);
    }

    /**
     * Posts the {@link Event_Notification} object
     *
     * @access  public
     * @param   object      The Notification object
     * @param   bool        Whether to post the notification immediately
     * @param   bool        Whether you want the notification to bubble up
     * @see Event_Dispatcher::post()
     * @return  object  The notification object
     */
    function &postNotification(&$notification, $pending = true, $bubble = true)
    {
        $nName = $notification->getNotificationName();
        if ($pending === true) {
            $this->_pending[$nName][] =& $notification;
        }
        $objClass = get_class($notification->getNotificationObject());

        // Find the registered observers
        if (isset($this->_ro[$nName])) {
            foreach (array_keys($this->_ro[$nName]) as $k) {
                $rObserver =& $this->_ro[$nName][$k];
                if ($notification->isNotificationCancelled()) {
                    return $notification;
                }
                if (empty($rObserver['class']) ||
                	strcasecmp($rObserver['class'], $objClass) == 0) {
                    call_user_func_array($rObserver['callback'], array(&$notification));
                    $notification->increaseNotificationCount();
                }
            }
        }

        // Notify globally registered observers
        if (isset($this->_ro[EVENT_DISPATCHER_GLOBAL])) {
            foreach (array_keys($this->_ro[EVENT_DISPATCHER_GLOBAL]) as $k) {
                $rObserver =& $this->_ro[EVENT_DISPATCHER_GLOBAL][$k];
                if ($notification->isNotificationCancelled()) {
                    return $notification;
                }
                if (empty($rObserver['class']) || 
                	strcasecmp($rObserver['class'], $objClass) == 0) {
                    call_user_func_array($rObserver['callback'], array(&$notification));
                    $notification->increaseNotificationCount();
                }
            }
        }

        if ($bubble === false) {
            return $notification;
        }
        
        // Notify in nested dispatchers
        foreach (array_keys($this->_nestedDispatchers) as $nested) {
            $notification =& $this->_nestedDispatchers[$nested]->postNotification($notification, $pending);
        }

        return $notification;
    }

    /**
     * Removes a registered observer that correspond to the given criteria
     *
     * @access  public
     * @param   mixed       A PHP callback
     * @param   string      Notification name
     * @param   string      Contained object class
     * @return  bool    True if an observer was removed, false otherwise
     */
    function removeObserver($callback, $nName = EVENT_DISPATCHER_GLOBAL, $class = null)
    {
        if (is_array($callback)) {
            if (is_object($callback[0])) {
                $reg = get_class($callback[0]).'::'.$callback[1];
            } else {
                $reg = $callback[0].'::'.$callback[1];
            }
        } else {
            $reg = $callback;
        }

        $removed = false;
        if (isset($this->_ro[$nName][$reg])) {
            if (!empty($class)) {
                if (strcasecmp($this->_ro[$nName][$reg]['class'], $class) == 0) {
                    unset($this->_ro[$nName][$reg]);
                    $removed = true;
                }
            } else {
                unset($this->_ro[$nName][$reg]);
                $removed = true;
            }
        }

        if (isset($this->_ro[$nName]) && count($this->_ro[$nName]) == 0) {
            unset($this->_ro[$nName]);
        }
        return $removed;
    }

   /**
    * Check, whether the specified observer has been registered with the
    * dispatcher
    *
     * @access  public
     * @param   mixed       A PHP callback
     * @param   string      Notification name
     * @param   string      Contained object class
     * @return  bool        True if the observer has been registered, false otherwise
    */
    function observerRegistered($callback, $nName = EVENT_DISPATCHER_GLOBAL, $class = null)
    {
        if (is_array($callback)) {
            if (is_object($callback[0])) {
                $reg = get_class($callback[0]).'::'.$callback[1];
            } else {
                $reg = $callback[0].'::'.$callback[1];
            }
        } else {
            $reg = $callback;
        }

        if (!isset($this->_ro[$nName][$reg])) {
            return false;
        }
        if (empty($class)) {
            return true;
        }
        if (strcasecmp($this->_ro[$nName][$reg]['class'], $class) == 0) {
            return true;
        }
        return false;
    }

   /**
    * Get all observers, that have been registered for a notification
    *
     * @access  public
     * @param   string      Notification name
     * @param   string      Contained object class
     * @return  array       List of all observers
    */
    function getObservers($nName = EVENT_DISPATCHER_GLOBAL, $class = null)
    {
        $observers = array();        
        if (!isset($this->_ro[$nName])) {
            return $observers;
        }
        foreach ($this->_ro[$nName] as $reg => $observer) {
        	if ($class == null || $observer['class'] == null ||  strcasecmp($observer['class'], $class) == 0) {
        		$observers[] = $reg;
        	}
        }
        return $observers;
    }
    
    /**
     * Get the name of the dispatcher.
     *
     * The name is the unique identifier of a dispatcher.
     *
     * @access   public
     * @return   string     name of the dispatcher
     */
    function getName()
    {
        return $this->_name;
    }

    /**
     * add a new nested dispatcher
     *
     * Notifications will be broadcasted to this dispatcher as well, which
     * allows you to create event bubbling.
     *
     * @access   public
     * @param    Event_Dispatcher    The nested dispatcher
     */
    function addNestedDispatcher(&$dispatcher)
    {
        $name = $dispatcher->getName();
        $this->_nestedDispatchers[$name] =& $dispatcher;
    }

   /**
    * remove a nested dispatcher
    *
    * @access   public
    * @param    Event_Dispatcher    Dispatcher to remove
    * @return   boolean
    */
    function removeNestedDispatcher($dispatcher)
    {
        if (is_object($dispatcher)) {
            $dispatcher = $dispatcher->getName();
        }
        if (!isset($this->_nestedDispatchers[$dispatcher])) {
            return false;
        }
        unset($this->_nestedDispatchers[$dispatcher]);
        return true;
    }

    /**
     * Changes the class used for notifications
     *
     * You may call this method on an object to change it for a single
     * dispatcher or statically, to set the default for all dispatchers
     * that will be created.
     *
     * @access   public
     * @param    string     name of the notification class
     * @return   boolean
     */
    function setNotificationClass($class)
    {
        if (isset($this) && is_a($this, 'Event_Dispatcher')) {
            $this->_notificationClass = $class;
            return true;
        }
        $GLOBALS['_Event_Dispatcher']['NotificationClass'] = $class;
        return true;
    }

}
?>
Creat By MiNi SheLL
Email: devilkiller@gmail.com